Beispiel #1
0
    public void ReadXml(XmlReader reader)
    {
        reader.ReadStartElement(); //wrapping element

        this.name = reader.ReadElementContentAsString();
        this.extension = reader.ReadElementContentAsString();

        string tempFileName = Path.GetTempFileName();
        this.streamFileName = tempFileName;
        using (FileStream fs = File.Create(tempFileName))
        {
            byte[] buffer = new byte[1000];
            int bytesRead;
            reader.ReadStartElement();
            do
            {
                bytesRead = reader.ReadContentAsBase64(buffer, 0, buffer.Length);
                fs.Write(buffer, 0, bytesRead);
            } while (bytesRead > 0);

            reader.ReadEndElement();
        }

        reader.ReadEndElement(); //wrapping element
    }
Beispiel #2
0
 void IXmlSerializable.ReadXml(XmlReader reader)
 {
     Value = Duck.Cast <IParser <TKey> >(typeof(TKey)).Parse(reader.ReadElementContentAsString());
 }
Beispiel #3
0
 void IXmlSerializable.ReadXml(XmlReader reader)
 {
     Value = Guid.Parse(reader.ReadElementContentAsString());
 }
Beispiel #4
0
        public static List <OrderStatus> Parse(Stream stream)
        {
            var items = new List <OrderStatus>();

            if (stream == null || !stream.CanRead)
            {
                return(items);
            }

            var stopwatch = new Stopwatch();

            stopwatch.Start();

            var settings = new XmlReaderSettings();

            settings.IgnoreWhitespace = true;
            settings.IgnoreComments   = true;


            using (XmlReader reader = XmlReader.Create(stream, settings))
            {
                /*
                 * Get result
                 */
                reader.ReadToFollowing("result");
                var result = reader.ReadElementContentAsString();
                Debug.Print("result: {0}", result);

                if (result != "OK")
                {
                    return(items);
                }

                string      lastElementName = string.Empty;
                OrderStatus oStatus         = null;

                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element && reader.NodeType != XmlNodeType.EndElement)
                    {
                        lastElementName = reader.LocalName;

                        if (reader.LocalName.Equals("orderstatus"))
                        {
                            oStatus = new OrderStatus();
                        }
                    }

                    if (reader.NodeType == XmlNodeType.Text)
                    {
                        if (oStatus != null)
                        {
                            switch (lastElementName)
                            {
                            case "order-number":
                                oStatus.OrderNumber = reader.Value;
                                break;

                            case "cancelable":
                                oStatus.Cancelable = Convert.ToBoolean(reader.Value);
                                break;

                            case "editable":
                                oStatus.Editable = Convert.ToBoolean(reader.Value);
                                break;

                            case "complex-option":
                                oStatus.ComplexOption = Convert.ToBoolean(reader.Value);
                                break;

                            case "enhanced-order":
                                oStatus.EnhancedOrder = Convert.ToBoolean(reader.Value);
                                break;

                            case "display-status":
                                oStatus.DisplayStatus = reader.Value;
                                break;

                            case "order-routing-status":
                                oStatus.OrderRoutingStatus = reader.Value;
                                break;

                            case "order-received-date-time":
                                oStatus.OrderReceivedDateTime = reader.Value;
                                break;

                            case "cancel-date-time":
                                oStatus.CancelDateTime = reader.Value;
                                break;

                            case "reported-time":
                                oStatus.ReportedTime = reader.Value;
                                break;

                            case "remaining-quantity":
                                oStatus.RemainingQuantity = Convert.ToSingle(reader.Value);
                                break;

                            case "trailing-activation-price":
                                oStatus.TrailingActivationPrice = Convert.ToSingle(reader.Value);
                                break;

                            case "account-id":
                                oStatus.AccountId = reader.Value;
                                break;

                            case "symbol":
                                oStatus.Symbol = reader.Value;
                                break;

                            case "symbol-with-type-prefix":
                                oStatus.SymbolWithTypePrefix = reader.Value;
                                break;

                            case "description":
                                oStatus.Description = reader.Value;
                                break;

                            case "asset-type":
                                oStatus.AssetType = reader.Value;
                                break;

                            case "quantity":
                                oStatus.Quantity = Convert.ToSingle(reader.Value);
                                break;

                            case "order-id":
                                oStatus.OrderId = reader.Value;
                                break;

                            case "action":
                                oStatus.Action = reader.Value;
                                break;

                            case "trade-type":
                                oStatus.TradeType = reader.Value;
                                break;

                            case "routing-mode":
                                oStatus.RoutingMode = reader.Value;
                                break;

                            case "option-exchange":
                                oStatus.OptionExchange = reader.Value;
                                break;

                            case "response-description":
                                oStatus.ResponseDescription = reader.Value;
                                break;

                            case "routing-display-size":
                                oStatus.RoutingDisplaySize = Convert.ToSingle(reader.Value);
                                break;

                            case "order-type":
                                oStatus.OrderType = reader.Value;
                                break;

                            case "limit-price":
                                oStatus.LimitPrice = Convert.ToSingle(reader.Value);
                                break;

                            case "stop-price":
                                oStatus.StopPrice = Convert.ToSingle(reader.Value);
                                break;

                            case "session":
                                oStatus.Session = reader.Value;
                                break;

                            case "expiration":
                                oStatus.Expiration = reader.Value;
                                break;

                            default:
                                Debug.Print("Not processed: {0}", lastElementName);
                                break;
                            }
                        }
                    }

                    if (reader.NodeType == XmlNodeType.EndElement)
                    {
                        if (reader.LocalName.Equals("orderstatus"))
                        {
                            items.Add(oStatus);
                        }
                    }
                }
            }

            return(items);
        }
        /// <summary>
        /// Gets the StockDetails.
        /// </summary>
        /// <param name="reader">The reader.</param>

        private StockDetails GetStockDetails(XmlReader reader)
        {
            if (reader == null)
            {
                throw new Exception("reader");
            }
            while (reader.NodeType != XmlNodeType.Element)
            {
                reader.Read();
            }
            if (reader.LocalName != "StockDetails")
            {
                throw new XmlException("Unexpected xml tag " + reader.LocalName);
            }
            reader.Read();
            while (reader.NodeType == XmlNodeType.Whitespace)
            {
                reader.Read();
            }
            StockDetails stockDetails = new StockDetails();

            while (reader.LocalName != "StockDetails")
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.LocalName)
                    {
                    case "TradeNo":
                        stockDetails.TradeNo = reader.ReadElementContentAsString();
                        break;

                    case "CompanyName":
                        stockDetails.CompanyName = reader.ReadElementContentAsString();
                        break;

                    case "CostPrice":
                        stockDetails.CostPrice = reader.ReadElementContentAsString();
                        break;

                    case "SharesCount":
                        stockDetails.SharesCount = reader.ReadElementContentAsString();
                        break;

                    case "SalesPrice":
                        stockDetails.SalesPrice = reader.ReadElementContentAsString();
                        break;

                    default:
                        reader.Skip();
                        break;
                    }
                }
                else
                {
                    reader.Read();
                    if ((reader.LocalName == "StockDetails") && reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;
                    }
                }
            }
            return(stockDetails);
        }
Beispiel #6
0
        static public void LoadWorld(Game game, string filepath)
        {
            XmlReaderSettings settings = new XmlReaderSettings();

            settings.IgnoreWhitespace = true;
            XmlReader reader = XmlReader.Create(new StreamReader(filepath, Encoding.GetEncoding("UTF-8")), settings);

            List <Encounter> encounters = new List <Encounter>();
            List <Room>      rooms      = new List <Room>();
            List <Item>      items      = new List <Item>();

            while (reader.Read())
            {
                string name  = reader.Name;
                string value = reader.Value;

                switch (name)
                {
                case "encounter":

                    reader.ReadStartElement();
                    string        announcement         = reader.ReadElementContentAsString();
                    string        monsterName          = reader.ReadElementContentAsString();
                    int           monsterHealth        = reader.ReadElementContentAsInt();
                    int           gold                 = reader.ReadElementContentAsInt();
                    List <string> attackNames          = new List <string>();
                    List <int>    attackProbabilities  = new List <int>();
                    List <int>    attackDamages        = new List <int>();
                    List <string> abilityNames         = new List <string>();
                    List <int>    abilityProbabilities = new List <int>();
                    List <string> abilityMods          = new List <string>();
                    List <int>    itemRewards          = new List <int>();

                    reader.ReadStartElement();
                    while (reader.Name == "att")
                    {
                        string[] attack = reader.ReadElementContentAsString().Split(':');
                        attackProbabilities.Add(Convert.ToInt32(attack[0]));
                        attackNames.Add(attack[1]);
                        attackDamages.Add(Convert.ToInt32(attack[2]));
                    }
                    if (attackNames.Count > 0)
                    {
                        reader.ReadEndElement();
                    }

                    reader.ReadStartElement();
                    while (reader.Name == "att")
                    {
                        string[] attack = reader.ReadElementContentAsString().Split(':');
                        abilityProbabilities.Add(Convert.ToInt32(attack[0]));
                        abilityNames.Add(attack[1]);
                        abilityMods.Add(attack[2]);
                    }
                    if (abilityNames.Count > 0)
                    {
                        reader.ReadEndElement();
                    }

                    reader.ReadStartElement();
                    while (reader.Name == "reward")
                    {
                        string[] itemString = reader.ReadElementContentAsString().Split(':');
                        itemRewards.Add(Convert.ToInt32(itemString[0]));
                    }
                    if (itemRewards.Count > 0)
                    {
                        reader.ReadEndElement();
                    }

                    string win  = reader.ReadElementContentAsString();
                    string lose = reader.ReadElementContentAsString();

                    encounters.Add(new Encounter(monsterName, monsterHealth, gold, itemRewards.ToArray(), announcement, win, lose, attackNames.ToArray(), attackDamages.ToArray(), attackProbabilities.ToArray(), abilityNames.ToArray(), abilityMods.ToArray(), abilityProbabilities.ToArray()));
                    break;

                case "room":
                    reader.ReadStartElement();

                    string   roomName   = reader.ReadElementContentAsString();
                    string   desc       = reader.ReadElementContentAsString();
                    int      encIndex   = reader.ReadElementContentAsInt();
                    string[] keyStrings = reader.ReadElementContentAsString().Split(':');
                    string[] navStrings = reader.ReadElementContentAsString().Split(':');

                    int[] keyMetas = new int[]
                    {
                        Convert.ToInt32(keyStrings[0]),
                        Convert.ToInt32(keyStrings[1]),
                        Convert.ToInt32(keyStrings[2]),
                        Convert.ToInt32(keyStrings[3])
                    };

                    int[] navTable = new int[]
                    {
                        Convert.ToInt32(navStrings[0]),
                        Convert.ToInt32(navStrings[1]),
                        Convert.ToInt32(navStrings[2]),
                        Convert.ToInt32(navStrings[3])
                    };

                    Room room = new Room(roomName, desc, encIndex, navTable, keyMetas);
                    rooms.Add(room);
                    break;

                case "item":
                    reader.ReadStartElement();
                    string    itemname = reader.ReadElementContentAsString();
                    ItemTypes type     = (ItemTypes)reader.ReadElementContentAsInt();
                    int       itemmeta = reader.ReadElementContentAsInt();

                    Item item = new Item(itemname, type, itemmeta);
                    items.Add(item);
                    break;
                }
            }

            game.encounters = encounters.ToArray();
            game.rooms      = rooms.ToArray();
            game.items      = items.ToArray();
        }
Beispiel #7
0
        private void FetchMainEpisodeInfo(MetadataResult <Episode> result, XmlReader reader, CancellationToken cancellationToken)
        {
            var item = result.Item;

            // Use XmlReader for best performance
            using (reader)
            {
                reader.MoveToContent();

                result.ResetPeople();

                // Loop through each element
                while (reader.Read())
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                        case "id":
                        {
                            var val = reader.ReadElementContentAsString();
                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                item.SetProviderId(MetadataProviders.Tvdb, val);
                            }
                            break;
                        }

                        case "IMDB_ID":
                        {
                            var val = reader.ReadElementContentAsString();
                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                item.SetProviderId(MetadataProviders.Imdb, val);
                            }
                            break;
                        }

                        case "DVD_episodenumber":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                float num;

                                if (float.TryParse(val, NumberStyles.Any, _usCulture, out num))
                                {
                                    item.DvdEpisodeNumber = num;
                                }
                            }

                            break;
                        }

                        case "DVD_season":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                float num;

                                if (float.TryParse(val, NumberStyles.Any, _usCulture, out num))
                                {
                                    item.DvdSeasonNumber = Convert.ToInt32(num);
                                }
                            }

                            break;
                        }

                        case "EpisodeNumber":
                        {
                            if (!item.IndexNumber.HasValue)
                            {
                                var val = reader.ReadElementContentAsString();

                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    int rval;

                                    // int.TryParse is local aware, so it can be probamatic, force us culture
                                    if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                    {
                                        item.IndexNumber = rval;
                                    }
                                }
                            }

                            break;
                        }

                        case "SeasonNumber":
                        {
                            if (!item.ParentIndexNumber.HasValue)
                            {
                                var val = reader.ReadElementContentAsString();

                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    int rval;

                                    // int.TryParse is local aware, so it can be probamatic, force us culture
                                    if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                    {
                                        item.ParentIndexNumber = rval;
                                    }
                                }
                            }

                            break;
                        }

                        case "absolute_number":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                int rval;

                                // int.TryParse is local aware, so it can be probamatic, force us culture
                                if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                {
                                    item.AbsoluteEpisodeNumber = rval;
                                }
                            }

                            break;
                        }

                        case "airsbefore_episode":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                int rval;

                                // int.TryParse is local aware, so it can be probamatic, force us culture
                                if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                {
                                    item.AirsBeforeEpisodeNumber = rval;
                                }
                            }

                            break;
                        }

                        case "airsafter_season":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                int rval;

                                // int.TryParse is local aware, so it can be probamatic, force us culture
                                if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                {
                                    item.AirsAfterSeasonNumber = rval;
                                }
                            }

                            break;
                        }

                        case "airsbefore_season":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                int rval;

                                // int.TryParse is local aware, so it can be probamatic, force us culture
                                if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                {
                                    item.AirsBeforeSeasonNumber = rval;
                                }
                            }

                            break;
                        }

                        case "EpisodeName":
                        {
                            if (!item.LockedFields.Contains(MetadataFields.Name))
                            {
                                var val = reader.ReadElementContentAsString();
                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    item.Name = val;
                                }
                            }
                            break;
                        }

                        case "Overview":
                        {
                            if (!item.LockedFields.Contains(MetadataFields.Overview))
                            {
                                var val = reader.ReadElementContentAsString();
                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    item.Overview = val;
                                }
                            }
                            break;
                        }

                        case "Rating":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                float rval;

                                // float.TryParse is local aware, so it can be probamatic, force us culture
                                if (float.TryParse(val, NumberStyles.AllowDecimalPoint, _usCulture, out rval))
                                {
                                    item.CommunityRating = rval;
                                }
                            }
                            break;
                        }

                        case "RatingCount":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                int rval;

                                // int.TryParse is local aware, so it can be probamatic, force us culture
                                if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                                {
                                    item.VoteCount = rval;
                                }
                            }

                            break;
                        }

                        case "FirstAired":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                DateTime date;
                                if (DateTime.TryParse(val, out date))
                                {
                                    date = date.ToUniversalTime();

                                    item.PremiereDate   = date;
                                    item.ProductionYear = date.Year;
                                }
                            }

                            break;
                        }

                        case "Director":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddPeople(result, val, PersonType.Director);
                                }
                            }

                            break;
                        }

                        case "GuestStars":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddGuestStars(result, val);
                                }
                            }

                            break;
                        }

                        case "Writer":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddPeople(result, val, PersonType.Writer);
                                }
                            }

                            break;
                        }

                        default:
                            reader.Skip();
                            break;
                        }
                    }
                }
            }
        }
 public void ReadXml(XmlReader reader)
 {
     _Value = new Uri(reader.ReadElementContentAsString());
 }
Beispiel #9
0
        /// <summary>
        /// Fetches metadata from one Xml Element
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <param name="itemResult">The item result.</param>
        protected virtual void FetchDataFromXmlNode(XmlReader reader, MetadataResult <T> itemResult)
        {
            var item = itemResult.Item;

            switch (reader.Name)
            {
            // DateCreated
            case "Added":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    if (DateTime.TryParse(val, out var added))
                    {
                        item.DateCreated = added.ToUniversalTime();
                    }
                    else
                    {
                        Logger.LogWarning("Invalid Added value found: " + val);
                    }
                }
                break;
            }

            case "OriginalTitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrEmpty(val))
                {
                    item.OriginalTitle = val;
                }
                break;
            }

            case "LocalTitle":
                item.Name = reader.ReadElementContentAsString();
                break;

            case "CriticRating":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrEmpty(text))
                {
                    if (float.TryParse(text, NumberStyles.Any, _usCulture, out var value))
                    {
                        item.CriticRating = value;
                    }
                }

                break;
            }

            case "SortTitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.ForcedSortName = val;
                }
                break;
            }

            case "Overview":
            case "Description":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.Overview = val;
                }

                break;
            }

            case "Language":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataLanguage = val;

                break;
            }

            case "CountryCode":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataCountryCode = val;

                break;
            }

            case "PlaceOfBirth":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var person = item as Person;
                    if (person != null)
                    {
                        person.ProductionLocations = new string[] { val };
                    }
                }

                break;
            }

            case "LockedFields":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.LockedFields = val.Split('|').Select(i =>
                        {
                            if (Enum.TryParse(i, true, out MetadataFields field))
                            {
                                return((MetadataFields?)field);
                            }

                            return(null);
                        }).Where(i => i.HasValue).Select(i => i.Value).ToArray();
                }

                break;
            }

            case "TagLines":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromTaglinesNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "Countries":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromCountriesNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "ContentRating":
            case "MPAARating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    item.OfficialRating = rating;
                }
                break;
            }

            case "CustomRating":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.CustomRating = val;
                }
                break;
            }

            case "RunningTime":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(text))
                {
                    if (int.TryParse(text.Split(' ')[0], NumberStyles.Integer, _usCulture, out var runtime))
                    {
                        item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
                    }
                }
                break;
            }

            case "AspectRatio":
            {
                var val = reader.ReadElementContentAsString();

                var hasAspectRatio = item as IHasAspectRatio;
                if (!string.IsNullOrWhiteSpace(val) && hasAspectRatio != null)
                {
                    hasAspectRatio.AspectRatio = val;
                }
                break;
            }

            case "LockData":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
                }
                break;
            }

            case "Network":
            {
                foreach (var name in SplitNames(reader.ReadElementContentAsString()))
                {
                    if (string.IsNullOrWhiteSpace(name))
                    {
                        continue;
                    }
                    item.AddStudio(name);
                }
                break;
            }

            case "Director":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Director
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "Writer":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Writer
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "Actors":
            {
                var actors = reader.ReadInnerXml();

                if (actors.Contains("<"))
                {
                    // This is one of the mis-named "Actors" full nodes created by MB2
                    // Create a reader and pass it to the persons node processor
                    FetchDataFromPersonsNode(XmlReader.Create(new StringReader("<Persons>" + actors + "</Persons>")), itemResult);
                }
                else
                {
                    // Old-style piped string
                    foreach (var p in SplitNames(actors).Select(v => new PersonInfo {
                            Name = v.Trim(), Type = PersonType.Actor
                        }))
                    {
                        if (string.IsNullOrWhiteSpace(p.Name))
                        {
                            continue;
                        }
                        itemResult.AddPerson(p);
                    }
                }
                break;
            }

            case "GuestStars":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.GuestStar
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "Trailer":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.AddTrailerUrl(val);
                }
                break;
            }

            case "DisplayOrder":
            {
                var val = reader.ReadElementContentAsString();

                var hasDisplayOrder = item as IHasDisplayOrder;
                if (hasDisplayOrder != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasDisplayOrder.DisplayOrder = val;
                    }
                }
                break;
            }

            case "Trailers":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchDataFromTrailersNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "ProductionYear":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    if (int.TryParse(val, out var productionYear) && productionYear > 1850)
                    {
                        item.ProductionYear = productionYear;
                    }
                }

                break;
            }

            case "Rating":
            case "IMDBrating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    // All external meta is saving this as '.' for decimal I believe...but just to be sure
                    if (float.TryParse(rating.Replace(',', '.'), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var val))
                    {
                        item.CommunityRating = val;
                    }
                }
                break;
            }

            case "BirthDate":
            case "PremiereDate":
            case "FirstAired":
            {
                var firstAired = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(firstAired))
                {
                    if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out var airDate) && airDate.Year > 1850)
                    {
                        item.PremiereDate   = airDate.ToUniversalTime();
                        item.ProductionYear = airDate.Year;
                    }
                }

                break;
            }

            case "DeathDate":
            case "EndDate":
            {
                var firstAired = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(firstAired))
                {
                    if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out var airDate) && airDate.Year > 1850)
                    {
                        item.EndDate = airDate.ToUniversalTime();
                    }
                }

                break;
            }

            case "CollectionNumber":
                var tmdbCollection = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(tmdbCollection))
                {
                    item.SetProviderId(MetadataProviders.TmdbCollection, tmdbCollection);
                }
                break;

            case "Genres":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromGenresNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "Tags":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromTagsNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "Persons":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchDataFromPersonsNode(subtree, itemResult);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "Studios":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromStudiosNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            case "Shares":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        var hasShares = item as IHasShares;
                        if (hasShares != null)
                        {
                            FetchFromSharesNode(subtree, hasShares);
                        }
                    }
                }
                else
                {
                    reader.Read();
                }
                break;
            }

            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;
            }

            default:
            {
                string readerName = reader.Name;
                if (_validProviderIds.TryGetValue(readerName, out string providerIdValue))
                {
                    var id = reader.ReadElementContentAsString();
                    if (!string.IsNullOrWhiteSpace(id))
                    {
                        item.SetProviderId(providerIdValue, id);
                    }
                }
                else
                {
                    reader.Skip();
                }

                break;
            }
            }
        }
Beispiel #10
0
        /// <summary>
        /// Gets the persons from XML node.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <returns>IEnumerable{PersonInfo}.</returns>
        private IEnumerable <PersonInfo> GetPersonsFromXmlNode(XmlReader reader)
        {
            var name      = string.Empty;
            var type      = PersonType.Actor; // If type is not specified assume actor
            var role      = string.Empty;
            int?sortOrder = null;

            reader.MoveToContent();
            reader.Read();

            // Loop through each element
            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                    case "Name":
                        name = reader.ReadElementContentAsString() ?? string.Empty;
                        break;

                    case "Type":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            type = val;
                        }
                        break;
                    }

                    case "Role":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            role = val;
                        }
                        break;
                    }

                    case "SortOrder":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            if (int.TryParse(val, NumberStyles.Integer, _usCulture, out var intVal))
                            {
                                sortOrder = intVal;
                            }
                        }
                        break;
                    }

                    default:
                        reader.Skip();
                        break;
                    }
                }
                else
                {
                    reader.Read();
                }
            }

            var personInfo = new PersonInfo
            {
                Name      = name.Trim(),
                Role      = role,
                Type      = type,
                SortOrder = sortOrder
            };

            return(new[] { personInfo });
        }
 protected virtual string EncryptPassword(string document)
 {
   string str1 = document;
   XmlWriter xmlWriter = (XmlWriter) null;
   XmlReader reader = (XmlReader) null;
   bool flag1 = false;
   try
   {
     StringBuilder sb = new StringBuilder();
     xmlWriter = (XmlWriter) new XmlTextWriter((TextWriter) new StringWriter(sb));
     XmlReaderSettings settings = new XmlReaderSettings();
     settings.IgnoreWhitespace = true;
     reader = XmlReader.Create((TextReader) new StringReader(document), settings);
     if (reader.Read())
     {
       do
       {
         if (reader.NodeType == XmlNodeType.Element && (reader.LocalName == "__session" || reader.LocalName == "__connect"))
           reader.Read();
         else if (reader.NodeType == XmlNodeType.Element && (reader.LocalName == "password" || reader.LocalName == "sessionId"))
         {
           for (bool flag2 = reader.MoveToFirstAttribute(); flag2; flag2 = reader.MoveToNextAttribute())
           {
             if (reader.LocalName == "__encrypted" && string.Compare(reader.Value, "yes", true) == 0)
               flag1 = true;
           }
           reader.Close();
         }
         else
           reader.Read();
       }
       while (!reader.EOF && reader.ReadState != System.Xml.ReadState.Closed);
     }
     reader = XmlReader.Create((TextReader) new StringReader(document), settings);
     if (reader.Read())
     {
       do
       {
         if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "__InSite")
         {
           string str2 = (string) null;
           xmlWriter.WriteStartElement(reader.LocalName);
           for (bool flag2 = reader.MoveToFirstAttribute(); flag2; flag2 = reader.MoveToNextAttribute())
           {
             if (reader.LocalName == "__encryption")
               str2 = reader.Value;
             else
               xmlWriter.WriteAttributeString(reader.LocalName, reader.Value);
           }
           if (!flag1)
             str2 = "2";
           if (!string.IsNullOrEmpty(str2))
             xmlWriter.WriteAttributeString("__encryption", str2);
           reader.Read();
         }
         else if (reader.NodeType == XmlNodeType.Element && (reader.LocalName == "__session" || reader.LocalName == "__connect"))
         {
           xmlWriter.WriteStartElement(reader.LocalName);
           xmlWriter.WriteAttributes(reader, true);
           reader.Read();
         }
         else if (reader.NodeType == XmlNodeType.EndElement && (reader.LocalName == "__session" || reader.LocalName == "__connect"))
         {
           xmlWriter.WriteEndElement();
           reader.Read();
         }
         else if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "password")
         {
           if (!flag1)
           {
             xmlWriter.WriteStartElement(reader.LocalName);
             for (bool flag2 = reader.MoveToFirstAttribute(); flag2; flag2 = reader.MoveToNextAttribute())
             {
               if (reader.LocalName != "__encrypted")
                 xmlWriter.WriteAttributeString(reader.LocalName, reader.Value);
             }
             xmlWriter.WriteAttributeString("__encrypted", "yes");
             int content = (int) reader.MoveToContent();
             string fieldData = reader.ReadElementContentAsString();
             xmlWriter.WriteValue(CryptUtil.Encrypt(fieldData));
             xmlWriter.WriteEndElement();
           }
           else
             xmlWriter.WriteNode(reader, true);
         }
         else
           xmlWriter.WriteNode(reader, true);
       }
       while (!reader.EOF);
       str1 = sb.ToString();
     }
   }
   catch (Exception ex)
   {
     str1 = document;
     this.LogEntry(string.Format("Password encrypting error: {0}", (object) ex.Message), EventLogEntryType.Error);
   }
   finally
   {
     reader?.Close();
     xmlWriter?.Close();
   }
   return str1;
 }
Beispiel #12
0
        /// <summary>
        /// Reads the string safe.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <returns>System.String.</returns>
        public static string ReadStringSafe(this XmlReader reader)
        {
            var val = reader.ReadElementContentAsString();

            return(string.IsNullOrWhiteSpace(val) ? null : val);
        }
        public void ReadXml(XmlReader reader)
        {
            if (!reader.IsEmptyElement)
            {
                reader.Read();
            }
            while (!reader.EOF)
            {
                if (reader.IsEmptyElement && !reader.HasAttributes)
                {
                    reader.Read();
                    continue;
                }

                if (reader.IsEmptyElement && reader.HasAttributes)
                {
                    while (reader.MoveToNextAttribute())
                    {
                        var attributeName = reader.Name;
                        switch (reader.Name)
                        {
                        case "id": Id = reader.ReadAttributeAsInt(attributeName); break;

                        case "issue_id": IssueId = reader.ReadAttributeAsInt(attributeName); break;

                        case "issue_to_id": IssueToId = reader.ReadAttributeAsInt(attributeName); break;

                        case "relation_type":
                            var rt = reader.GetAttribute(attributeName);
                            if (!string.IsNullOrEmpty(rt))
                            {
                                Type = (IssueRelationType)Enum.Parse(typeof(IssueRelationType), rt, true);
                            }
                            break;

                        case "delay": Delay = reader.ReadAttributeAsNullableInt(attributeName); break;
                        }
                    }
                    return;
                }

                switch (reader.Name)
                {
                case "id": Id = reader.ReadElementContentAsInt(); break;

                case "issue_id": IssueId = reader.ReadElementContentAsInt(); break;

                case "issue_to_id": IssueToId = reader.ReadElementContentAsInt(); break;

                case "relation_type":
                    var rt = reader.ReadElementContentAsString();
                    if (!string.IsNullOrEmpty(rt))
                    {
                        Type = (IssueRelationType)Enum.Parse(typeof(IssueRelationType), rt, true);
                    }
                    break;

                case "delay": Delay = reader.ReadElementContentAsNullableInt(); break;

                default: reader.Read(); break;
                }
            }
        }
Beispiel #14
0
                void ParseHeaderElement( XmlReader reader, float parentWidth, float parentHeight, uint? parentBGColor, out PlatformLabel element, ref RectangleF elementBounds, ref Styles.Style defaultStyle )
                {
                    element = PlatformLabel.Create( );

                    // header elements are weird with styles. We don't want any of our parent's styles,
                    // so we create our own and mix that with our defaults
                    Styles.Style elementStyle = new Styles.Style( );
                    elementStyle.Initialize( );
                    elementStyle.mBackgroundColor = parentBGColor.HasValue ? parentBGColor.Value : 0; //one exception is background color. We do want to inherit that.
                    Styles.Style.ParseStyleAttributesWithDefaults( reader, ref elementStyle, ref defaultStyle );

                    // Note: Margins and padding are not supported by the individual elements of the header.

                    element.SetFont( elementStyle.mFont.mName, elementStyle.mFont.mSize.Value );
                    element.TextColor = elementStyle.mFont.mColor.Value;

                    if( elementStyle.mBackgroundColor.HasValue )
                    {
                        element.BackgroundColor = elementStyle.mBackgroundColor.Value;
                    }

                    element.Bounds = elementBounds;

                    // get text
                    switch( elementStyle.mTextCase )
                    {
                        case Styles.TextCase.Upper:
                        {
                            element.Text = reader.ReadElementContentAsString( ).ToUpper( );
                            break;
                        }

                        case Styles.TextCase.Lower:
                        {
                            element.Text = reader.ReadElementContentAsString( ).ToLower( );
                            break;
                        }

                        case Styles.TextCase.Normal:
                        {
                            element.Text = reader.ReadElementContentAsString( );
                            break;
                        }
                    }
                    element.SizeToFit( );

                    // horizontally position the controls according to their
                    // requested alignment
                    Styles.Alignment controlAlignment = elementStyle.mAlignment.Value;

                    // adjust by our position
                    float xAdjust = 0;
                    switch( controlAlignment )
                    {
                        case Styles.Alignment.Center:
                        {
                            xAdjust = elementBounds.X + ( ( parentWidth / 2 ) - ( element.Bounds.Width / 2 ) );
                            element.TextAlignment = TextAlignment.Center;
                            break;
                        }
                        case Styles.Alignment.Right:
                        {
                            xAdjust = elementBounds.X + ( parentWidth - element.Bounds.Width );
                            element.TextAlignment = TextAlignment.Right;
                            break;
                        }
                        case Styles.Alignment.Left:
                        {
                            xAdjust = elementBounds.X;
                            element.TextAlignment = TextAlignment.Left;
                            break;
                        }
                    }

                    // adjust position
                    element.Position = new PointF( elementBounds.X + xAdjust, elementBounds.Y );
                }
        private void AddImage(XmlReader reader, List <RemoteImageInfo> images)
        {
            reader.MoveToContent();

            string bannerType   = null;
            string url          = null;
            int?   bannerSeason = null;
            int?   width        = null;
            int?   height       = null;
            string language     = null;
            double?rating       = null;
            int?   voteCount    = null;
            string thumbnailUrl = null;

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                    case "Rating":
                    {
                        var val = reader.ReadElementContentAsString() ?? string.Empty;

                        double rval;

                        if (double.TryParse(val, NumberStyles.Any, _usCulture, out rval))
                        {
                            rating = rval;
                        }

                        break;
                    }

                    case "RatingCount":
                    {
                        var val = reader.ReadElementContentAsString() ?? string.Empty;

                        int rval;

                        if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                        {
                            voteCount = rval;
                        }

                        break;
                    }

                    case "Language":
                    {
                        language = reader.ReadElementContentAsString() ?? string.Empty;
                        break;
                    }

                    case "ThumbnailPath":
                    {
                        thumbnailUrl = reader.ReadElementContentAsString() ?? string.Empty;
                        break;
                    }

                    case "BannerType":
                    {
                        bannerType = reader.ReadElementContentAsString() ?? string.Empty;

                        break;
                    }

                    case "BannerPath":
                    {
                        url = reader.ReadElementContentAsString() ?? string.Empty;
                        break;
                    }

                    case "BannerType2":
                    {
                        var bannerType2 = reader.ReadElementContentAsString() ?? string.Empty;

                        // Sometimes the resolution is stuffed in here
                        var resolutionParts = bannerType2.Split('x');

                        if (resolutionParts.Length == 2)
                        {
                            int rval;

                            if (int.TryParse(resolutionParts[0], NumberStyles.Integer, _usCulture, out rval))
                            {
                                width = rval;
                            }

                            if (int.TryParse(resolutionParts[1], NumberStyles.Integer, _usCulture, out rval))
                            {
                                height = rval;
                            }
                        }

                        break;
                    }

                    case "Season":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            bannerSeason = int.Parse(val);
                        }
                        break;
                    }


                    default:
                        reader.Skip();
                        break;
                    }
                }
            }

            if (!string.IsNullOrEmpty(url) && !bannerSeason.HasValue)
            {
                var imageInfo = new RemoteImageInfo
                {
                    RatingType      = RatingType.Score,
                    CommunityRating = rating,
                    VoteCount       = voteCount,
                    Url             = TVUtils.BannerUrl + url,
                    ProviderName    = Name,
                    Language        = language,
                    Width           = width,
                    Height          = height
                };

                if (!string.IsNullOrEmpty(thumbnailUrl))
                {
                    imageInfo.ThumbnailUrl = TVUtils.BannerUrl + thumbnailUrl;
                }

                if (string.Equals(bannerType, "poster", StringComparison.OrdinalIgnoreCase))
                {
                    imageInfo.Type = ImageType.Primary;
                    images.Add(imageInfo);
                }
                else if (string.Equals(bannerType, "series", StringComparison.OrdinalIgnoreCase))
                {
                    imageInfo.Type = ImageType.Banner;
                    images.Add(imageInfo);
                }
                else if (string.Equals(bannerType, "fanart", StringComparison.OrdinalIgnoreCase))
                {
                    imageInfo.Type = ImageType.Backdrop;
                    images.Add(imageInfo);
                }
            }
        }
Beispiel #16
0
        public void ReadXml(XmlReader r)
        {
            r.ReadStartElement();

            while (r.NodeType == XmlNodeType.Element)
            {
                switch (r.Name)
                {
                case "LeftImageRoot":
                    LeftImageRoot = r.ReadElementContentAsString();
                    break;

                case "LeftImageSubdir":
                    LeftImageSubdir = r.ReadElementContentAsString();
                    break;

                case "LeftImageFile":
                    LeftImageFile = r.ReadElementContentAsString();
                    break;

                case "LeftVideoRoot":
                    LeftVideoRoot = r.ReadElementContentAsString();
                    break;

                case "LeftVideoSubdir":
                    LeftVideoSubdir = r.ReadElementContentAsString();
                    break;

                case "LeftVideoFile":
                    LeftVideoFile = r.ReadElementContentAsString();
                    break;

                case "RightImageRoot":
                    RightImageRoot = r.ReadElementContentAsString();
                    break;

                case "RightImageSubdir":
                    RightImageSubdir = r.ReadElementContentAsString();
                    break;

                case "RightImageFile":
                    RightImageFile = r.ReadElementContentAsString();
                    break;

                case "RightVideoRoot":
                    RightVideoRoot = r.ReadElementContentAsString();
                    break;

                case "RightVideoSubdir":
                    RightVideoSubdir = r.ReadElementContentAsString();
                    break;

                case "RightVideoFile":
                    RightVideoFile = r.ReadElementContentAsString();
                    break;

                case "ImageFormat":
                    ImageFormat = (KinoveaImageFormat)Enum.Parse(typeof(KinoveaImageFormat), r.ReadElementContentAsString());
                    break;

                case "VideoFormat":
                    VideoFormat = (KinoveaVideoFormat)Enum.Parse(typeof(KinoveaVideoFormat), r.ReadElementContentAsString());
                    break;

                case "UncompressedVideoFormat":
                    UncompressedVideoFormat = (KinoveaUncompressedVideoFormat)Enum.Parse(typeof(KinoveaUncompressedVideoFormat), r.ReadElementContentAsString());
                    break;

                default:
                    string outerXml = r.ReadOuterXml();
                    log.DebugFormat("Unparsed content in XML: {0}", outerXml);
                    break;
                }
            }

            r.ReadEndElement();
        }
        public static void ReadObjectProperties(XmlReader reader, object obj, PropertyConversionHandler handler = null)
        {
            // Build property lookup table
            PropertyInfo[] props = obj.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
            Dictionary<string, PropertyInfo> propHash = new Dictionary<string, PropertyInfo>(props.Length);
            foreach (var pi in props)
                if (!Attribute.IsDefined(pi, typeof(XmlIgnoreAttribute), false))
                    propHash.Add(GetPropertyElementName(pi), pi);

            while (reader.MoveToContent() == System.Xml.XmlNodeType.Element)
            {
                PropertyInfo pi;
                if (propHash.TryGetValue(reader.LocalName, out pi))
                {
                    if (IsStandardType(pi.PropertyType))
                    {
                        object value = null;
                        if (pi.PropertyType.IsEnum)
                            value = Enum.Parse(pi.PropertyType, reader.ReadElementContentAsString());
                        else
                            value = reader.ReadElementContentAs(pi.PropertyType, null);

                        if (handler != null)
                            handler(pi, obj, ref value);

                        pi.SetValue(obj, value, null);
                    }
                    else
                    {
                        ReadObject(reader, pi.GetValue(obj, null));
                    }
                }
                else
                {
                    reader.Skip();
                    reader.MoveToContent();
                }
            }
        }
        public List <OrderHistory> Parse(Stream stream)
        {
            var items = new List <OrderHistory>();

            if (stream == null || !stream.CanRead)
            {
                return(items);
            }

            var stopwatch = new Stopwatch();

            stopwatch.Start();

            var settings = new XmlReaderSettings();

            settings.IgnoreWhitespace = true;
            settings.IgnoreComments   = true;

            try
            {
                using (XmlReader reader = XmlReader.Create(stream, settings))
                {
                    /*
                     * Get result
                     */
                    reader.ReadToFollowing("result");
                    var result = reader.ReadElementContentAsString();
                    Debug.Print("result: {0}", result);

                    if (result != "OK")
                    {
                        return(items);
                    }

                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element &&
                            reader.LocalName.Equals("transaction-list"))
                        {
                            var  trans   = new OrderHistory();
                            bool endItem = false;

                            while (!endItem && reader.Read())  // condition order is important because reader.Read() won't be executed if endQuote = true
                            {
                                if (reader.NodeType == XmlNodeType.Element &&
                                    reader.NodeType != XmlNodeType.EndElement)
                                {
                                    switch (reader.LocalName)
                                    {
                                    case "error":
                                        reader.Read();
                                        trans.Error = reader.Value;
                                        break;

                                    case "executedDate":
                                        reader.Read();
                                        if (!string.IsNullOrEmpty(reader.Value) && reader.Value.Contains("EDT"))
                                        {
                                            trans.ExecutedDate = DateTime.ParseExact(reader.Value, "yyyy-MM-dd HH:mm:ss EDT", CultureInfo.InvariantCulture).ToUniversalTime().ToLocalTime();
                                        }
                                        else if (!string.IsNullOrEmpty(reader.Value) && reader.Value.Contains("EST"))
                                        {
                                            trans.ExecutedDate = DateTime.ParseExact(reader.Value, "yyyy-MM-dd HH:mm:ss EST", CultureInfo.InvariantCulture).ToUniversalTime().ToLocalTime();
                                        }
                                        break;

                                    case "orderNumber":
                                        reader.Read();
                                        trans.OrderNumber = reader.Value;
                                        break;

                                    case "orderDateTime":
                                        reader.Read();
                                        trans.OrderDateTime = reader.Value;
                                        break;

                                    case "buySellCode":
                                        reader.Read();
                                        trans.BuySellCode = reader.Value;
                                        break;

                                    case "assetType":
                                        reader.Read();
                                        trans.AssetType = reader.Value;
                                        break;

                                    case "type":
                                        reader.Read();
                                        trans.Type = reader.Value;
                                        break;

                                    case "subType":
                                        reader.Read();
                                        trans.SubType = reader.Value;
                                        break;

                                    case "symbol":
                                        reader.Read();
                                        trans.Symbol = reader.Value;
                                        break;

                                    case "description":
                                        reader.Read();
                                        trans.Description = reader.Value;
                                        break;

                                    case "cusip":
                                        reader.Read();
                                        trans.CUSIP = reader.Value;
                                        break;

                                    case "price":
                                        reader.Read();
                                        trans.Price = (!string.IsNullOrEmpty(reader.Value))
                                                              ? Convert.ToSingle(reader.Value)
                                                              : 0;
                                        break;

                                    case "quantity":
                                        reader.Read();
                                        trans.Quantity = (!string.IsNullOrEmpty(reader.Value))
                                                                 ? Convert.ToSingle(reader.Value)
                                                                 : 0;
                                        break;

                                    case "transactionId":
                                        reader.Read();
                                        trans.TransactionId = reader.Value;
                                        break;

                                    case "value":
                                        reader.Read();
                                        trans.Value = (!string.IsNullOrEmpty(reader.Value))
                                                              ? Convert.ToSingle(reader.Value)
                                                              : 0;
                                        break;

                                    case "commission":
                                        reader.Read();
                                        trans.Commission = (!string.IsNullOrEmpty(reader.Value))
                                                                   ? Convert.ToSingle(reader.Value)
                                                                   : 0;
                                        break;

                                    case "fees":
                                        reader.Read();
                                        trans.Fees = (!string.IsNullOrEmpty(reader.Value))
                                                             ? Convert.ToSingle(reader.Value)
                                                             : 0;
                                        break;

                                    case "additionalFees":
                                        reader.Read();
                                        trans.AdditionalFees = (!string.IsNullOrEmpty(reader.Value))
                                                                       ? Convert.ToSingle(reader.Value)
                                                                       : 0;
                                        break;

                                    case "cashBalanceEffect":
                                        reader.Read();
                                        trans.CashBalanceEffect = reader.Value;
                                        break;

                                    case "openClose":
                                        reader.Read();
                                        trans.TransactionId = reader.Value;
                                        break;

                                    case "optionType":
                                        reader.Read();
                                        trans.OptionType = reader.Value;
                                        break;

                                    case "optionExpireDate":
                                        reader.Read();
                                        trans.OptionExpireDate = reader.Value;
                                        break;

                                    case "optionStrike":
                                        reader.Read();
                                        trans.OptionStrike = (!string.IsNullOrEmpty(reader.Value))
                                                                     ? Convert.ToSingle(reader.Value)
                                                                     : 0;
                                        break;

                                    case "accruedInterest":
                                        reader.Read();
                                        trans.AccruedInterest = (!string.IsNullOrEmpty(reader.Value))
                                                                        ? Convert.ToSingle(reader.Value)
                                                                        : 0;
                                        break;

                                    case "parentChildIndicator":
                                        reader.Read();
                                        trans.ParentChildIndicator = reader.Value;
                                        break;

                                    case "sharesBefore":
                                        reader.Read();
                                        trans.SharesBefore = (!string.IsNullOrEmpty(reader.Value))
                                                                     ? Convert.ToSingle(reader.Value)
                                                                     : 0;
                                        break;

                                    case "sharesAfter":
                                        reader.Read();
                                        trans.SharesAfter = (!string.IsNullOrEmpty(reader.Value))
                                                                    ? Convert.ToSingle(reader.Value)
                                                                    : 0;
                                        break;

                                    case "otherCharges":
                                        reader.Read();
                                        trans.OtherChanges = (!string.IsNullOrEmpty(reader.Value))
                                                                     ? Convert.ToSingle(reader.Value)
                                                                     : 0;
                                        break;

                                    case "redemptionFee":
                                        reader.Read();
                                        trans.RedemptionFee = (!string.IsNullOrEmpty(reader.Value))
                                                                      ? Convert.ToSingle(reader.Value)
                                                                      : 0;
                                        break;

                                    case "cdscFee":
                                        reader.Read();
                                        trans.CDSCFee = (!string.IsNullOrEmpty(reader.Value))
                                                                ? Convert.ToSingle(reader.Value)
                                                                : 0;
                                        break;

                                    case "bondInterestRate":
                                        reader.Read();
                                        trans.BondInterestRate = (!string.IsNullOrEmpty(reader.Value))
                                                                         ? Convert.ToSingle(reader.Value)
                                                                         : 0;
                                        break;

                                    case "SplitRatio":
                                        reader.Read();
                                        trans.SplitRatio = reader.Value;
                                        break;

                                    case "bankingStatus":
                                        reader.Read();
                                        trans.AccountType = reader.Value;
                                        break;

                                    case "accountType":
                                        reader.Read();
                                        trans.AccountType = reader.Value;
                                        break;

                                    default:
                                        Debug.Print("Not processed: {0}", reader.LocalName);
                                        break;
                                    }
                                }
                                else if (reader.NodeType == XmlNodeType.EndElement &&
                                         reader.LocalName == "transaction-list")
                                {
                                    //Debug.Print("Symbol: {0}, Change: {1}, Change(%): {2:P2}", quote.Symbol, quote.Change, quote.ChangePercent);
                                    items.Add(trans);
                                    endItem = true;
                                }
                            }
                        }
                        else if (reader.NodeType == XmlNodeType.Element &&
                                 reader.LocalName.Equals("account-id"))
                        {
                            reader.Read();
                            AccoundId = reader.Value;
                        }
                        else if (reader.NodeType == XmlNodeType.Element &&
                                 reader.LocalName.Equals("startDate"))
                        {
                            reader.Read();
                            StartDate = reader.Value;
                        }
                        else if (reader.NodeType == XmlNodeType.Element &&
                                 reader.LocalName.Equals("endDate"))
                        {
                            reader.Read();
                            EndDate = reader.Value;
                        }
                        else if (reader.NodeType == XmlNodeType.Element &&
                                 reader.LocalName.Equals("searchTransactionType"))
                        {
                            reader.Read();
                            SearchTransactionType = reader.Value;
                        }
                        else if (reader.NodeType == XmlNodeType.Element &&
                                 reader.LocalName.Equals("requestType"))
                        {
                            reader.Read();
                            RequestType = reader.Value;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Debug.Print("Reading Xml Error: {0}", e.Message);
            }

            stopwatch.Stop();

            Debug.Print("Time Elasped: {0} miliseconds, Count={1}", stopwatch.ElapsedMilliseconds, items.Count);

            if (items.Count > 0)
            {
                LastParseTime = DateTime.Now;
            }
            else
            {
                LastParseTime = DateTime.MinValue;
            }

            return(items);
        }
Beispiel #19
0
        protected override void ReadClassSpecificXml(XmlReader reader)
        {
            //we creeren de artikelen hier
            //we lezen de data van de reader
            _alleArtikelen.Clear();
            _artikelen.Clear();
            while (reader.ReadToFollowing("Artikel"))
            {
                if (reader.ReadToDescendant("ID") == false)
                {
                    continue;
                }
                Guid id = Guid.Parse(reader.ReadElementContentAsString());

                if (reader.ReadToNextSibling("Naam") == false)
                {
                    continue;
                }
                string naam = reader.ReadElementContentAsString();

                if (reader.ReadToNextSibling("Omschrijving") == false)
                {
                    continue;
                }
                string omschrijving = reader.ReadElementContentAsString();

                if (reader.ReadToNextSibling("Type") == false)
                {
                    continue;
                }
                string type = reader.ReadElementContentAsString();

                if (reader.ReadToNextSibling("Gewicht") == false)
                {
                    continue;
                }
                double gewicht = double.Parse(reader.ReadElementContentAsString());

                if (reader.ReadToNextSibling("Prijs") == false)
                {
                    continue;
                }
                decimal prijs = decimal.Parse(reader.ReadElementContentAsString(), CultureInfo.InvariantCulture);

                if (reader.ReadToNextSibling("Artikelnummer") == false)
                {
                    continue;
                }
                int artikelnummer = int.Parse(reader.ReadElementContentAsString());

                if (reader.ReadToNextSibling("Modelnummer") == false)
                {
                    continue;
                }
                int modelnummer = int.Parse(reader.ReadElementContentAsString());

                if (reader.ReadToNextSibling("Serienummer") == false)
                {
                    continue;
                }
                int serienummer = int.Parse(reader.ReadElementContentAsString());

                if (reader.ReadToNextSibling("AangemaaktOp") == false)
                {
                    continue;
                }
                DateTime aangemaaktOp = DateTime.Parse(reader.ReadElementContentAsString());

                if (reader.ReadToNextSibling("Garantieduur") == false)
                {
                    continue;
                }
                DateTime garantieDuur = DateTime.Parse(reader.ReadElementContentAsString());

                if (reader.ReadToNextSibling("Verpakking") == false)
                {
                    continue;
                }
                Guid verpakking = Guid.Parse(reader.ReadElementContentAsString());

                if (reader.ReadToNextSibling("BTW") == false)
                {
                    continue;
                }
                int btw = int.Parse(reader.ReadElementContentAsString());

                Artikel artikel = new Artikel(id, naam, omschrijving, type, gewicht, prijs, artikelnummer, modelnummer, serienummer, aangemaaktOp, garantieDuur, verpakking, btw);
                _alleArtikelen.Add(artikel);
            }


            for (int i = 0; i < _alleArtikelen.Count; ++i)
            {
                if (_alleArtikelen[i] == null)
                {
                    continue;                            //zou niet mogen
                }
                string id = _alleArtikelen[i].ID.ToString();
                if (_artikelen.ContainsKey(id) == false)
                {
                    _artikelen.Add(id, _alleArtikelen[i]);
                }
            }
        }
Beispiel #20
0
        private async Task GetYoutubeDataGroupAsync(string Uid, string Keyword, int MaxResults, int Page = 0)
        {
            string text = string.Concat(new object[]
            {
                "http://gdata.youtube.com/feeds/api/videos?max-results=",
                MaxResults,
                "&v=2&q=",
                Keyword,
                "&start-index=",
                ((Page * MaxResults) + 1)
            });

            new Uri(text);
            YoutubeDataGroup result;

            try
            {
                YoutubeDataItem  item             = null;
                YoutubeDataGroup youtubeDataGroup = new YoutubeDataGroup(Uid, "Search: " + Keyword, Keyword, "ms-appx:///Assets/Darkgray.png", "");
                WebRequest       webRequest       = WebRequest.Create(text);
                webRequest.Method = "GET";
                WebResponse webResponse = await webRequest.GetResponseAsync();

                XDocument xDocument   = XDocument.Load(webResponse.GetResponseStream());
                XmlReader xmlReader   = xDocument.CreateReader();
                int       num         = 0;
                string    title       = string.Empty;
                string    str         = string.Empty;
                string    str2        = string.Empty;
                string    description = string.Empty;
                //SearchFeedResults.Clear();
                while (xmlReader.Read())
                {
                    if (xmlReader.NodeType == XmlNodeType.Element)
                    {
                        string text2    = string.Empty;
                        string expr_1BE = xmlReader.Name;
                        if (expr_1BE != null)
                        {
                            if (!(expr_1BE == "yt:videoid"))
                            {
                                if (!(expr_1BE == "title"))
                                {
                                    if (!(expr_1BE == "media:credit"))
                                    {
                                        if (!(expr_1BE == "media:description"))
                                        {
                                            if (expr_1BE == "yt:duration")
                                            {
                                                int num2 = Convert.ToInt32(xmlReader["seconds"]);
                                                if (num2 > 60)
                                                {
                                                    int num3 = num2 / 60;
                                                    int num4 = num2 % 60;
                                                    if (num4 < 10)
                                                    {
                                                        str2 = num3.ToString() + ":0" + num4.ToString();
                                                    }
                                                    else
                                                    {
                                                        str2 = num3.ToString() + ":" + num4.ToString();
                                                    }
                                                }
                                                else
                                                {
                                                    str2 = "0:" + num2.ToString();
                                                }
                                            }
                                        }
                                        else
                                        {
                                            description = xmlReader.ReadElementContentAsString();
                                        }
                                    }
                                    else
                                    {
                                        str = xmlReader["yt:display"];
                                    }
                                }
                                else
                                {
                                    title = xmlReader.ReadElementContentAsString();
                                }
                            }
                            else
                            {
                                text2 = xmlReader.ReadElementContentAsString();
                                string imagePath = "http://i.ytimg.com/vi/" + text2 + "/hqdefault.jpg";
                                item = new YoutubeDataItem(num.ToString(), title, "by " + str + " | " + str2, imagePath, description, text2, youtubeDataGroup);
                                youtubeDataGroup.Items.Add(item);
                                StandardFeedResults.Add(item);
                            }
                        }
                    }
                    num++;
                }
                result = youtubeDataGroup;
            }
            catch (Exception)
            {
                result = null;
            }
            return;
        }
Beispiel #21
0
        private void FetchAdditionalPartInfo(MetadataResult <Episode> result, XmlReader reader, CancellationToken cancellationToken)
        {
            var item = result.Item;

            // Use XmlReader for best performance
            using (reader)
            {
                reader.MoveToContent();

                // Loop through each element
                while (reader.Read())
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                        case "EpisodeName":
                        {
                            if (!item.LockedFields.Contains(MetadataFields.Name))
                            {
                                var val = reader.ReadElementContentAsString();
                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    item.Name += ", " + val;
                                }
                            }
                            break;
                        }

                        case "Overview":
                        {
                            if (!item.LockedFields.Contains(MetadataFields.Overview))
                            {
                                var val = reader.ReadElementContentAsString();
                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    item.Overview += Environment.NewLine + Environment.NewLine + val;
                                }
                            }
                            break;
                        }

                        case "Director":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddPeople(result, val, PersonType.Director);
                                }
                            }

                            break;
                        }

                        case "GuestStars":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddGuestStars(result, val);
                                }
                            }

                            break;
                        }

                        case "Writer":
                        {
                            var val = reader.ReadElementContentAsString();

                            if (!string.IsNullOrWhiteSpace(val))
                            {
                                if (!item.LockedFields.Contains(MetadataFields.Cast))
                                {
                                    AddPeople(result, val, PersonType.Writer);
                                }
                            }

                            break;
                        }

                        default:
                            reader.Skip();
                            break;
                        }
                    }
                }
            }
        }
Beispiel #22
0
        private async Task <YoutubeDataItem> GetYoutubeDataItemAsync(string Uid, string videoID, YoutubeDataGroup group)
        {
            string text = "http://gdata.youtube.com/feeds/api/videos/" + videoID + "?v=2";

            new Uri(text);
            YoutubeDataItem result;

            try
            {
                YoutubeDataItem youtubeDataItem = null;
                WebRequest      webRequest      = WebRequest.Create(text);
                webRequest.Method = "GET";
                WebResponse webResponse = await webRequest.GetResponseAsync();

                XDocument xDocument   = XDocument.Load(webResponse.GetResponseStream());
                XmlReader xmlReader   = xDocument.CreateReader();
                int       num         = 0;
                string    title       = string.Empty;
                string    str         = string.Empty;
                string    str2        = string.Empty;
                string    description = string.Empty;
                while (xmlReader.Read())
                {
                    if (xmlReader.NodeType == XmlNodeType.Element)
                    {
                        string text2    = string.Empty;
                        string expr_165 = xmlReader.Name;
                        if (expr_165 != null)
                        {
                            if (!(expr_165 == "yt:videoid"))
                            {
                                if (!(expr_165 == "title"))
                                {
                                    if (!(expr_165 == "media:credit"))
                                    {
                                        if (!(expr_165 == "media:description"))
                                        {
                                            if (expr_165 == "yt:duration")
                                            {
                                                int num2 = Convert.ToInt32(xmlReader["seconds"]);
                                                if (num2 > 60)
                                                {
                                                    int num3 = num2 / 60;
                                                    int num4 = num2 % 60;
                                                    if (num4 < 10)
                                                    {
                                                        str2 = num3.ToString() + ":0" + num4.ToString();
                                                    }
                                                    else
                                                    {
                                                        str2 = num3.ToString() + ":" + num4.ToString();
                                                    }
                                                }
                                                else
                                                {
                                                    str2 = "0:" + num2.ToString();
                                                }
                                            }
                                        }
                                        else
                                        {
                                            description = xmlReader.ReadElementContentAsString();
                                        }
                                    }
                                    else
                                    {
                                        str = xmlReader["yt:display"];
                                    }
                                }
                                else
                                {
                                    title = xmlReader.ReadElementContentAsString();
                                }
                            }
                            else
                            {
                                text2 = xmlReader.ReadElementContentAsString();
                                string imagePath = "http://i.ytimg.com/vi/" + text2 + "/hqdefault.jpg";
                                youtubeDataItem = new YoutubeDataItem(text2, title, "by " + str + " | " + str2, imagePath, description, text2, group);
                            }
                        }
                    }
                    num++;
                }
                result = youtubeDataItem;
            }
            catch //(Exception ex)
            {
                result = null;
            }
            return(result);
        }
Beispiel #23
0
        public void ReadXml(XmlReader reader)
        {
            while (!reader.EOF)
            {
                if (reader.IsStartElement())
                {
                    switch (reader.Name)
                    {
                    case ConverterSettingsElementName:
                        reader.MoveToContent();
                        string versionAttribute = reader.GetAttribute(VersionAttributeName);
                        if (string.IsNullOrEmpty(versionAttribute))
                        {
                            throw new InvalidDataException("The configuration file does not have a version attribute, probably old version");
                        }
                        int version;
                        if (!int.TryParse(versionAttribute, out version))
                        {
                            throw new InvalidDataException(string.Format("Unable to parse file version : {0}", versionAttribute));
                        }
                        if (version > ConfigurationFileVersion)
                        {
                            throw new InvalidDataException(string.Format("The file version is {0} while program can read only up to {1}", version, ConfigurationFileVersion));
                        }
                        reader.MoveToElement();
                        break;

                    case Fb2epubSettings.FB2ImportSettings.FB2ImportSettingsElementName:
                        _fb2ImportSettings.ReadXml(reader.ReadSubtree());
                        break;

                    case EPubConversionSettings.ConversiononSettingsElementName:
                        _conversionSettings.ReadXml(reader.ReadSubtree());
                        break;

                    case EPubCommonSettings.CommonSettingsElementName:
                        _commonSettings.ReadXml(reader.ReadSubtree());
                        break;

                    case EPubV2Settings.V2SettingsElementName:
                        _v2Settings.ReadXml(reader.ReadSubtree());
                        break;

                    case EPubV3Settings.EPubV3SettingsElementName:
                        _v3Settings.ReadXml(reader.ReadSubtree());
                        break;

                    case ResourcesPathElementName:
                        _resourcesPath = reader.ReadElementContentAsString();
                        continue;

                    case EPUBVersionElementName:
                        EPubVersion ePubVersion;
                        string      elementContent = reader.ReadElementContentAsString();
                        if (!Enum.TryParse(elementContent, true, out ePubVersion))
                        {
                            throw new InvalidDataException(string.Format("Invalid epub version : {0}", elementContent));
                        }
                        _standardVersion = ePubVersion;
                        continue;
                    }
                }
                reader.Read();
            }
        }
Beispiel #24
0
        private async Task <YoutubeDataGroup> GetStandardfeedAsync(string Uid, string standardfeed)
        {
            string text = "http://gdata.youtube.com/feeds/api/standardfeeds/" + standardfeed + "?v=2&max-results=25";

            new Uri(text);
            string title = string.Empty;
            string empty = string.Empty;

            switch (standardfeed)
            {
            case "top_rated":
                title = "Top Rated";
                break;

            case "top_favorites":
                title = "Favorites";
                break;

            case "most_viewed":
                title = "Most Viewed";
                break;

            case "most_shared":
                title = "Most Shared";
                break;

            case "most_popular":
                title = "Most Popular";
                break;

            case "most_recent":
                title = "Most Recent";
                break;

            case "most_discussed":
                title = "Most Discussed";
                break;

            case "most_responded":
                title = "Most Responded";
                break;

            case "recently_featured":
                title = "Recently Featured";
                break;

            case "on_the_web":
                title = "Trends";
                break;
            }
            YoutubeDataGroup result;

            try
            {
                YoutubeDataItem  item             = null;
                YoutubeDataGroup youtubeDataGroup = new YoutubeDataGroup(Uid, title, empty, "ms-appx:///Assets/Darkgray.png", "");
                string           empty2           = string.Empty;
                WebRequest       webRequest       = WebRequest.Create(text);
                webRequest.Method = "GET";
                WebResponse webResponse = await webRequest.GetResponseAsync();

                XDocument xDocument   = XDocument.Load(webResponse.GetResponseStream());
                XmlReader xmlReader   = xDocument.CreateReader();
                int       num2        = 0;
                string    text2       = string.Empty;
                string    str         = string.Empty;
                string    str2        = string.Empty;
                string    description = string.Empty;
                while (xmlReader.Read())
                {
                    if (xmlReader.NodeType == XmlNodeType.Element)
                    {
                        string text3    = string.Empty;
                        string expr_31D = xmlReader.Name;
                        if (expr_31D != null)
                        {
                            if (!(expr_31D == "yt:videoid"))
                            {
                                if (!(expr_31D == "title"))
                                {
                                    if (!(expr_31D == "media:credit"))
                                    {
                                        if (!(expr_31D == "media:description"))
                                        {
                                            if (expr_31D == "yt:duration")
                                            {
                                                int num3 = Convert.ToInt32(xmlReader["seconds"]);
                                                if (num3 > 60)
                                                {
                                                    int num4 = num3 / 60;
                                                    int num5 = num3 % 60;
                                                    if (num5 < 10)
                                                    {
                                                        str2 = num4.ToString() + ":0" + num5.ToString();
                                                    }
                                                    else
                                                    {
                                                        str2 = num4.ToString() + ":" + num5.ToString();
                                                    }
                                                }
                                                else
                                                {
                                                    str2 = "0:" + num3.ToString();
                                                }
                                            }
                                        }
                                        else
                                        {
                                            description = xmlReader.ReadElementContentAsString();
                                        }
                                    }
                                    else
                                    {
                                        str = xmlReader["yt:display"];
                                    }
                                }
                                else
                                {
                                    text2 = xmlReader.ReadElementContentAsString();
                                }
                            }
                            else
                            {
                                text3 = xmlReader.ReadElementContentAsString();
                                string text4 = "http://i.ytimg.com/vi/" + text3 + "/hqdefault.jpg";
                                if (empty2 == string.Empty)
                                {
                                    youtubeDataGroup.SetImage(text4);
                                }
                                item           = new YoutubeDataItem(Uid + num2.ToString() + text2, text2, "by " + str + " | " + str2, text4, description, text3, youtubeDataGroup);
                                item._Grouping = standardfeed;
                                youtubeDataGroup.Items.Add(item);
                            }
                        }
                    }
                    num2++;
                }
                webRequest.Abort();
                webResponse.Dispose();
                webRequest  = null;
                webResponse = null;
                xmlReader   = null;
                xDocument   = null;
                item        = null;
                result      = youtubeDataGroup;
            }
            catch (Exception)
            {
                result = null;
            }
            return(result);
        }
        /// <summary>
        /// Reads the current element as a urn and returns the contents as a string.
        /// </summary>
        /// <param name="reader">The current reader.</param>
        /// <returns>The element content as a string.</returns>
        public static string ReadElementContentAsUrn(this XmlReader reader)
        {
            var id = reader.ReadElementContentAsString();

            return(id != null && id.StartsWith("urn:uuid:") ? id.Substring(9) : id);
        }
Beispiel #26
0
        private async Task <YoutubeDataGroup> GetUserFavoriteFeedAsync(string Uid, string user)
        {
            string text = "http://gdata.youtube.com/feeds/api/users/" + user + "/favorites?v=2&max-results=25";

            new Uri(text);
            YoutubeDataGroup result;

            try
            {
                YoutubeDataItem  item             = null;
                YoutubeDataGroup youtubeDataGroup = new YoutubeDataGroup(Uid, user.ToUpper(), "", "ms-appx:///Assets/Darkgray.png", "");
                WebRequest       webRequest       = WebRequest.Create(text);
                webRequest.Method = "GET";
                WebResponse webResponse = await webRequest.GetResponseAsync();

                XDocument xDocument   = XDocument.Load(webResponse.GetResponseStream());
                XmlReader xmlReader   = xDocument.CreateReader();
                int       num         = 0;
                string    title       = string.Empty;
                string    str         = string.Empty;
                string    str2        = string.Empty;
                string    description = string.Empty;
                while (xmlReader.Read())
                {
                    if (xmlReader.NodeType == XmlNodeType.Element)
                    {
                        string text2    = string.Empty;
                        string expr_193 = xmlReader.Name;
                        if (expr_193 != null)
                        {
                            if (!(expr_193 == "yt:videoid"))
                            {
                                if (!(expr_193 == "title"))
                                {
                                    if (!(expr_193 == "media:credit"))
                                    {
                                        if (!(expr_193 == "media:description"))
                                        {
                                            if (!(expr_193 == "yt:duration"))
                                            {
                                                if (expr_193 == "gd:rating")
                                                {
                                                    float.Parse(xmlReader["average"].ToString());
                                                }
                                            }
                                            else
                                            {
                                                int num2 = Convert.ToInt32(xmlReader["seconds"]);
                                                if (num2 > 60)
                                                {
                                                    int num3 = num2 / 60;
                                                    int num4 = num2 % 60;
                                                    if (num4 < 10)
                                                    {
                                                        str2 = num3.ToString() + ":0" + num4.ToString();
                                                    }
                                                    else
                                                    {
                                                        str2 = num3.ToString() + ":" + num4.ToString();
                                                    }
                                                }
                                                else
                                                {
                                                    str2 = "0:" + num2.ToString();
                                                }
                                            }
                                        }
                                        else
                                        {
                                            description = xmlReader.ReadElementContentAsString();
                                        }
                                    }
                                    else
                                    {
                                        str = xmlReader["yt:display"];
                                    }
                                }
                                else
                                {
                                    title = xmlReader.ReadElementContentAsString();
                                }
                            }
                            else
                            {
                                text2 = xmlReader.ReadElementContentAsString();
                                string imagePath = "http://i.ytimg.com/vi/" + text2 + "/hqdefault.jpg";
                                item = new YoutubeDataItem(Uid + num.ToString(), title, "by " + str + " | " + str2, imagePath, description, text2, youtubeDataGroup);
                                youtubeDataGroup.Items.Add(item);
                            }
                        }
                    }
                    num++;
                }
                webRequest.Abort();
                webResponse.Dispose();
                webRequest  = null;
                webResponse = null;
                xmlReader   = null;
                xDocument   = null;
                item        = null;
                result      = youtubeDataGroup;
            }
            catch (Exception)
            {
                result = null;
            }
            return(result);
        }
Beispiel #27
0
        public static void AddEOSComp(XmlReader rdr, Computer compAttatchedTo, object osObj)
        {
            OS     os       = (OS)osObj;
            string compName = "Unregistered eOS Device";
            string str1     = compAttatchedTo.idName + "_eos";
            bool   flag     = false;

            if (rdr.MoveToAttribute("name"))
            {
                compName = ComputerLoader.filter(rdr.ReadContentAsString());
            }
            if (rdr.MoveToAttribute("id"))
            {
                str1 = rdr.ReadContentAsString();
            }
            if (rdr.MoveToAttribute("empty"))
            {
                flag = rdr.ReadContentAsString().ToLower() == "true";
            }
            string newPass = "******";

            if (rdr.MoveToAttribute("passOverride"))
            {
                newPass = rdr.ReadContentAsString();
            }
            Computer device = new Computer(compName, NetworkMap.generateRandomIP(), os.netMap.getRandomPosition(), 0, (byte)5, os);

            device.idName = str1;
            string str2 = "ePhone";

            if (rdr.MoveToAttribute("icon"))
            {
                str2 = rdr.ReadContentAsString();
            }
            device.icon     = str2;
            device.location = compAttatchedTo.location + Corporation.getNearbyNodeOffset(compAttatchedTo.location, Utils.random.Next(12), 12, os.netMap, 0.0f, false);
            device.setAdminPassword(newPass);
            ComputerLoader.loadPortsIntoComputer("22,3659", (object)device);
            device.portsNeededForCrack = 2;
            EOSComp.GenerateEOSFilesystem(device);
            rdr.Read();
            Folder folder1 = device.files.root.searchForFolder("eos");
            Folder folder2 = folder1.searchForFolder("notes");
            Folder folder3 = folder1.searchForFolder("mail");

            while (!(rdr.Name == "eosDevice") || rdr.IsStartElement())
            {
                if (rdr.Name.ToLower() == "note" && rdr.IsStartElement())
                {
                    string nameEntry = (string)null;
                    if (rdr.MoveToAttribute("filename"))
                    {
                        nameEntry = ComputerLoader.filter(rdr.ReadContentAsString());
                    }
                    int    content   = (int)rdr.MoveToContent();
                    string dataEntry = ComputerLoader.filter(rdr.ReadElementContentAsString().TrimStart());
                    if (nameEntry == null)
                    {
                        int length = dataEntry.IndexOf("\n");
                        if (length == -1)
                        {
                            length = dataEntry.IndexOf("\n");
                        }
                        if (length == -1)
                        {
                            length = dataEntry.Length;
                        }
                        string str3 = dataEntry.Substring(0, length);
                        if (str3.Length > 50)
                        {
                            str3 = str3.Substring(0, 47) + "...";
                        }
                        nameEntry = str3.Replace(" ", "_").Replace(":", "").ToLower().Trim() + ".txt";
                    }
                    FileEntry fileEntry = new FileEntry(dataEntry, nameEntry);
                    folder2.files.Add(fileEntry);
                }
                if (rdr.Name.ToLower() == "mail" && rdr.IsStartElement())
                {
                    string str3 = (string)null;
                    string str4 = (string)null;
                    if (rdr.MoveToAttribute("username"))
                    {
                        str3 = ComputerLoader.filter(rdr.ReadContentAsString());
                    }
                    if (rdr.MoveToAttribute("pass"))
                    {
                        str4 = ComputerLoader.filter(rdr.ReadContentAsString());
                    }
                    string dataEntry = "MAIL ACCOUNT : " + str3 + "\nAccount   :" + str3 + "\nPassword :"******"\nLast Sync :" + DateTime.Now.ToString() + "\n\n" + Computer.generateBinaryString(512);
                    string nameEntry = str3 + ".act";
                    folder3.files.Add(new FileEntry(dataEntry, nameEntry));
                }
                if (rdr.Name.ToLower() == "file" && rdr.IsStartElement())
                {
                    string nameEntry = (string)null;
                    if (rdr.MoveToAttribute("name"))
                    {
                        nameEntry = rdr.ReadContentAsString();
                    }
                    string path = "home";
                    if (rdr.MoveToAttribute("path"))
                    {
                        path = rdr.ReadContentAsString();
                    }
                    int    content   = (int)rdr.MoveToContent();
                    string dataEntry = ComputerLoader.filter(rdr.ReadElementContentAsString()).TrimStart();
                    device.getFolderFromPath(path, true).files.Add(new FileEntry(dataEntry, nameEntry));
                }
                rdr.Read();
                if (rdr.EOF)
                {
                    break;
                }
            }
            if (flag)
            {
                Folder folder4 = folder1.searchForFolder("apps");
                if (folder4 != null)
                {
                    folder4.files.Clear();
                    folder4.folders.Clear();
                }
            }
            os.netMap.nodes.Add(device);
            ComputerLoader.postAllLoadedActions += (Action)(() => device.links.Add(os.netMap.nodes.IndexOf(compAttatchedTo)));
            if (compAttatchedTo.attatchedDeviceIDs != null)
            {
                compAttatchedTo.attatchedDeviceIDs += ",";
            }
            compAttatchedTo.attatchedDeviceIDs += device.idName;
        }
Beispiel #28
0
        public static T ReadContentAsEnum <T>(this XmlReader reader)
        {
            var value = reader.ReadElementContentAsString();

            return((T)Enum.Parse(typeof(T), value));
        }
Beispiel #29
0
 void IXmlSerializable.ReadXml(XmlReader reader)
 {
     Value = reader.ReadElementContentAsString();
 }
Beispiel #30
0
            private static ReleaseResult ParseRelease(XmlReader reader, string releaseId)
            {
                var result = new ReleaseResult
                {
                    ReleaseId = releaseId
                };

                reader.MoveToContent();
                reader.Read();

                // http://stackoverflow.com/questions/2299632/why-does-xmlreader-skip-every-other-element-if-there-is-no-whitespace-separator

                // Loop through each element
                while (!reader.EOF && reader.ReadState == ReadState.Interactive)
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                        case "title":
                        {
                            result.Title = reader.ReadElementContentAsString();
                            break;
                        }

                        case "date":
                        {
                            var      val = reader.ReadElementContentAsString();
                            DateTime date;
                            if (DateTime.TryParse(val, out date))
                            {
                                result.Year = date.Year;
                            }
                            break;
                        }

                        case "annotation":
                        {
                            result.Overview = reader.ReadElementContentAsString();
                            break;
                        }

                        case "release-group":
                        {
                            result.ReleaseGroupId = reader.GetAttribute("id");
                            reader.Skip();
                            break;
                        }

                        default:
                        {
                            reader.Skip();
                            break;
                        }
                        }
                    }
                    else
                    {
                        reader.Read();
                    }
                }

                return(result);
            }
Beispiel #31
0
        public void ReadXml(XmlReader reader)
        {
            if (reader == null || reader.NodeType != XmlNodeType.Element)
            {
                return;
            }
            if (!string.Equals(reader.Name, "testSuite", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            string attribute = reader.GetAttribute("isDefault");

            if (!string.IsNullOrWhiteSpace(attribute))
            {
                _isDefault = XmlConvert.ToBoolean(attribute);
            }
            attribute = reader.GetAttribute("isSelected");
            if (!string.IsNullOrWhiteSpace(attribute))
            {
                _isSelected = XmlConvert.ToBoolean(attribute);
            }

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element &&
                    string.Equals(reader.Name, "property", StringComparison.OrdinalIgnoreCase))
                {
                    // <property name="Version">1.0</property>
                    string propertName   = reader.GetAttribute("name");
                    string propertyValue = reader.ReadElementContentAsString();
                    if (!string.IsNullOrWhiteSpace(propertName) && !string.IsNullOrWhiteSpace(propertyValue))
                    {
                        switch (propertName)
                        {
                        case "Version":
                            _version = propertyValue;
                            break;

                        case "Description":
                            _description = propertyValue;
                            break;

                        case "SuiteName":
                            _suiteName = propertyValue;
                            break;

                        case "SuiteDirName":
                            _suiteDirName = propertyValue;
                            break;

                        case "TestFileName":
                            _testFileName = propertyValue;
                            break;

                        case "ResultFileName":
                            _resultFileName = propertyValue;
                            break;

                        case "WebSuitePath":
                            _webSuitePath = propertyValue;
                            break;

                        case "LocalSuitePath":
                            _localSuitePath = propertyValue;
                            break;
                        }
                    }
                }
                else if (reader.NodeType == XmlNodeType.EndElement &&
                         string.Equals(reader.Name, "testSuite", StringComparison.OrdinalIgnoreCase))
                {
                    break;
                }
            }
        }
        public PhosphoRSInput Read()
        {
            var input = new PhosphoRSInput();

            while (_reader.Read())
            {
                if (_reader.NodeType == XmlNodeType.Element)
                {
                    if (_reader.Name == "Spectra")
                    {
                        if (input.Spectra == null)
                        {
                            input.Spectra = new List <Spectrum>();
                        }
                    }

                    if (_reader.Name == "Spectrum")
                    {
                        input.Spectra?.Add(new Spectrum(
                                               id: int.Parse(_reader["ID"]),
                                               name: _reader["Name"],
                                               precursorCharge: int.Parse(_reader["PrecursorCharge"]),
                                               activationType: SpectrumTypeHelper.ParseSpectrumType(_reader["ActivationTypes"]),
                                               peaks: null
                                               ));
                    }

                    if (_reader.Name == "Peaks")
                    {
                        var spectrum = input.Spectra?.LastOrDefault();
                        if (spectrum != null)
                        {
                            spectrum.Peaks = Peak.ParsePeaks(_reader.ReadElementContentAsString());
                        }
                    }

                    if (_reader.Name == "IdentifiedPhosphorPeptides")
                    {
                        var spectrum = input.Spectra?.LastOrDefault();
                        if (spectrum != null && spectrum.IdentifiedPhosphorPeptides == null)
                        {
                            spectrum.IdentifiedPhosphorPeptides = new List <Peptide>();
                        }
                    }

                    if (_reader.Name == "Peptide")
                    {
                        input.Spectra?.LastOrDefault()?.IdentifiedPhosphorPeptides?.Add(new Peptide(
                                                                                            id: int.Parse(_reader["ID"]),
                                                                                            sequence: _reader["Sequence"],
                                                                                            modification: _reader["ModificationInfo"]
                                                                                            ));
                    }

                    if (_reader.Name == "MassTolerance")
                    {
                        if (input.Options == null)
                        {
                            input.Options = new PhosphoRSOptions();
                        }
                        input.Options.MassTolerance = double.Parse(_reader["Value"]);
                    }

                    if (_reader.Name == "MaxIsoformCount")
                    {
                        if (input.Options == null)
                        {
                            input.Options = new PhosphoRSOptions();
                        }
                        input.Options.MaxIsoformCount = int.Parse(_reader["Value"]);
                    }

                    if (_reader.Name == "MaxPTMCount")
                    {
                        if (input.Options == null)
                        {
                            input.Options = new PhosphoRSOptions();
                        }
                        input.Options.MaxPTMCount = int.Parse(_reader["Value"]);
                    }

                    if (_reader.Name == "ScoreNeutralLoss")
                    {
                        if (input.Options == null)
                        {
                            input.Options = new PhosphoRSOptions();
                        }
                        input.Options.ScoreNeutralLoss = bool.Parse(_reader["Value"]);
                    }

                    if (_reader.Name == "Phosphorylation")
                    {
                        if (input.Options == null)
                        {
                            input.Options = new PhosphoRSOptions();
                        }
                        input.Options.PhosphorylationSymbol = char.Parse(_reader["Symbol"]);
                    }

                    if (_reader.Name == "ModificationInfos")
                    {
                        if (input.Modifications == null)
                        {
                            input.Modifications = new List <Modification>();
                        }
                    }

                    if (_reader.Name == "ModificationInfo")
                    {
                        var s = _reader["Value"]?.Split(':');
                        input.Modifications?.Add(new Modification(
                                                     symbol: char.Parse(_reader["Symbol"]),
                                                     name: s[1],
                                                     abbreviation: s[2],
                                                     massDelta: double.Parse(s[3]),
                                                     neutralLossAbbreviation: s[4],
                                                     neutralLoss: double.Parse(s[5]),
                                                     targetAminoAcids: s[6]
                                                     ));
                    }
                }
            }
            return(input);
        }
Beispiel #33
0
        protected override void FetchDataFromXmlNode(XmlReader reader, MetadataResult <Playlist> result)
        {
            var item = result.Item;

            switch (reader.Name)
            {
            case "OwnerUserId":
            {
                var userId = reader.ReadElementContentAsString();
                if (!item.Shares.Any(i => string.Equals(userId, i.UserId, StringComparison.OrdinalIgnoreCase)))
                {
                    item.Shares.Add(new Share
                        {
                            UserId  = userId,
                            CanEdit = true
                        });
                }

                break;
            }

            case "PlaylistMediaType":
            {
                item.PlaylistMediaType = reader.ReadElementContentAsString();

                break;
            }

            case "PlaylistItems":

                if (!reader.IsEmptyElement)
                {
                    using (var subReader = reader.ReadSubtree())
                    {
                        FetchFromCollectionItemsNode(subReader, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;

            case "Shares":

                if (!reader.IsEmptyElement)
                {
                    using (var subReader = reader.ReadSubtree())
                    {
                        FetchFromSharesNode(subReader, item);
                    }
                }
                else
                {
                    reader.Read();
                }
                break;

            default:
                base.FetchDataFromXmlNode(reader, result);
                break;
            }
        }
Beispiel #34
0
        public virtual void ReadXml(XmlReader r)
        {
            string str = r.ReadElementContentAsString();

            Deserialize(str);
        }
Beispiel #35
0
    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 static ushort ReadFile()
        {
            ErrorLog.Notice(String.Format("Checking For SmartThings Credentials File"));
            bool success = false;
            int isRead = 0;
            FileStream myFS = null;
            XmlReader myXMLReader = null;
            myCC.Enter(); // Will not finish, until you have the Critical Section
            try
            {
                //Check if the File Exists
                if (!Crestron.SimplSharp.CrestronIO.File.Exists(String.Format("\\NVRAM\\{0}\\SmartThings\\Credentials.xml", InitialParametersClass.ProgramIDTag)))
                {
                    ErrorLog.Error(String.Format("SmartThings Credentials File Not Found\n"));
                    ErrorLog.Error("Please Re Run the Authentication Sequence");
                    isRead = 1;
                }

                //File was Found, Now Read It.
                if (isRead == 0)
                {
                    myFS = new FileStream(String.Format("\\NVRAM\\{0}\\SmartThings\\Credentials.xml", InitialParametersClass.ProgramIDTag), FileMode.Open);
                    myXMLReader = new XmlReader(myFS);
                    myXMLReader.Read();
                    while (!myXMLReader.EOF)
                    {
                        if (myXMLReader.NodeType == XmlNodeType.Element)
                        {
                            switch (myXMLReader.Name.ToUpper())
                            {
                                case "CLIENTID":
                                    {
                                        string sTemp = myXMLReader.ReadElementContentAsString();
                                        if (SmartThingsReceiver.ClientID != sTemp)
                                        {
                                            ErrorLog.Error("SmartThings Credential File Does Not Match the Client ID provided in the Program!");
                                            ErrorLog.Error("Please Re Run the Authentication Sequence");
                                            ErrorLog.Notice("Module = {0}, File = {1}", ClientID, sTemp);
                                            break;
                                        }
                                        else
                                        {
                                            break;
                                        }
                                    }
                                case "AUTHCODE":
                                    {
                                        SmartThingsReceiver.AuthCode = myXMLReader.ReadElementContentAsString();
                                        break;
                                    }
                                case "ACCESSTOKEN":
                                    {
                                        SmartThingsReceiver.AccessToken = myXMLReader.ReadElementContentAsString();
                                        break;
                                    }
                                case "INSTALLATIONURL":
                                    {
                                        SmartThingsReceiver.InstallationURL = myXMLReader.ReadElementContentAsString();
                                        break;
                                    }
                               

                                default:
                                    {
                                        myXMLReader.Read();
                                        break;
                                    }
                            }
                        }
                        else
                        {
                            myXMLReader.Read();
                        }
                    }
                    success = true;
                    Authorized = 1;

                }
                else
                {
                    success = true;
                }
            }
            catch (Exception e)
            {
                //Crestron.SimplSharp.ErrorLog.Error(String.Format("ReadFile Error: {0}\n", e.Message));
                success = false;
            }
            finally
            {
                if (myXMLReader != null)
                    myXMLReader.Close();
                if (myFS != null)
                    myFS.Close();
                myCC.Leave();
            }
            if (success)
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }