Example #1
0
        public static void Create(InvoiceModel model, AppContext context)
        {
            EntityParser         parser            = new EntityParser();
            ModelFactory         factory           = new ModelFactory();
            Repository <Invoice> invoiceRepository = new Repository <Invoice>(context);
            Repository <Item>    itemRepository    = new Repository <Item>(context);

            Invoice invoice = new Invoice();

            invoice.Id       = model.Id;
            invoice.Date     = model.Date;
            invoice.Customer = context.Customers.Find(model.Customer);
            invoice.Status   = (Status)Enum.Parse(typeof(Status), model.Status);

            //a way to avoid a front-end problem when BillTo and Ship to are the same person - one of them is always null
            if (model.BillTo == null)
            {
                invoice.BillTo = context.Customers.Find(model.ShipTo.Id);
            }
            else if (model.ShipTo == null)
            {
                invoice.BillTo = context.Customers.Find(model.BillTo.Id);
            }
            else
            {
                invoice.BillTo = context.Customers.Find(model.BillTo.Id);
                invoice.ShipTo = context.Customers.Find(model.ShipTo.Id);
            }
            invoiceRepository.Insert(invoice);
        }
Example #2
0
        public void GetProperties_WhenEntityWithAttributes_ExpectPermittedNames()
        {
            // Arrange
            var entityParser = new EntityParser <TestEntity>();

            // Act
            var stopwatch           = Stopwatch.StartNew();
            var permittedProperties = entityParser.PermittedProperties;

            stopwatch.Stop();

            // Assert
            this.WriteTimeElapsed(stopwatch);

            Assert.That(permittedProperties, Is.Not.Null);

            var expected = new List <EntityProperty>
            {
                new EntityProperty {
                    InternalName = "PropertyFour", QueryName = "property_four", IsPermitted = true
                },
                new EntityProperty {
                    InternalName = "PropertyOne", QueryName = "PropertyOne", IsPermitted = true
                },
                new EntityProperty {
                    InternalName = "PropertyThree", QueryName = "property_three", IsPermitted = true
                }
            };

            permittedProperties.ShouldDeepEqual(expected);
        }
        public void DtoBuilder_SimpleEntity_PropertiesAdded()
        {
            var code     = SampleCodeProvider.EntityOnlySimpleProperties;
            var metadata = EntityParser.FromString(code);

            metadata.DtoName = "EntityOnlySimplePropertiesDTO";

            var tree = DtoBuilder.BuildDto(metadata, dtoNamespace: "Test.Namespace.Extra.Long");

            Assert.IsNotNull(tree);

            var codeText = tree.ToString();

            foreach (var prop in metadata.Properties.ToList())
            {
                Assert.IsTrue(codeText.Contains($"public {prop.Type} {prop.Name} {{ get; set; }}"));

                if (prop != metadata.Properties.Last())
                {
                    Assert.IsTrue(codeText.Contains($"{prop.Name} = p.{prop.Name},"));
                }
                else
                {
                    Assert.IsTrue(codeText.Contains($"{prop.Name} = p.{prop.Name}"));
                }

                Assert.IsFalse(codeText.Contains($",{prop.Name} = p.{prop.Name}"));

                Assert.IsTrue(codeText.Contains($"model.{prop.Name} = dto.{prop.Name};"));
            }

            Assert.IsTrue(codeText.Contains("using DtoGenerator.Tests.CodeSamples;"));
        }
        public void EntityParser_ParseEntity_MultipleClassDeclarations()
        {
            var code     = SampleCodeProvider.MultipleClasses;
            var metadata = EntityParser.FromString(code);

            Assert.Fail("Should not reach here.");
        }
        public void DtoBuilder_ComplexEntityDto_Regenerated()
        {
            var code     = SampleCodeProvider.ComplexEntity;
            var metadata = EntityParser.FromString(code);

            metadata.DtoName = "ComplexEntityDTO";
            var otherEntityProp = metadata.Properties.Where(p => p.RelatedEntityName == "OtherEntity").Single();

            otherEntityProp.RelationMetadata = EntityParser.FromString(SampleCodeProvider.OtherEntity);

            var existingDtoTree = CSharpSyntaxTree.ParseText(SampleCodeProvider.ComplexEntityDto);

            var tree = DtoBuilder.BuildDto(metadata, existingDto: existingDtoTree);

            Assert.IsNotNull(tree);

            var codeText = tree.ToString();

            Assert.IsTrue(codeText.Contains("public string OtherNumber { get; set; }"));
            Assert.IsTrue(codeText.Contains("OtherNumber = p.Other != null ? p.Other.Number : default (string),"));

            Assert.IsTrue(codeText.Contains("public IEnumerable<SomethingDTO> List1 { get; set; }"));
            Assert.IsTrue(codeText.Contains("public IEnumerable<SomethingDTO> Enumerable2 { get; set; }"));
            Assert.IsTrue(codeText.Contains("public IEnumerable<SomethingDTO> Collection2 { get; set; }"));

            Assert.IsTrue(codeText.Contains("List1 = p.List1.AsQueryable().Select(this._somethingMapper.SelectorExpression),"));
            Assert.IsTrue(codeText.Contains("Enumerable2 = p.Enumerable2.AsQueryable().Select(this._somethingMapper.SelectorExpression),"));
            Assert.IsTrue(codeText.Contains("Collection2 = p.Collection2.AsQueryable().Select(this._somethingMapper.SelectorExpression),"));
        }
        public static void UpdateCompany(CompanyModel model, AppContext context)
        {
            Repository <Company> companyRepository = new Repository <Company>(context);
            Company      company = new Company();
            EntityParser parser  = new EntityParser();

            company = parser.Create(model, context);
            companyRepository.Update(company, model.Id);
        }
Example #7
0
        public static void UpdateInvoice(InvoiceModel model, AppContext context)
        {
            Repository <Invoice> invoiceRepository = new Repository <Invoice>(context);
            Invoice      invoice = new Invoice();
            EntityParser parser  = new EntityParser();

            invoice = parser.Create(model, context);
            invoiceRepository.Update(invoice, model.Id);
        }
        private static IMetaDataBuilder ResolveMetaDataBuilder()
        {
            var genericTypesToMapToArray = new List<string> { "List`1", "IEnumerable`1" };

            var entityParser = new EntityParser(
                  new JavascriptTypeMapper(),
                  genericTypesToMapToArray,
                  ResolveValidationMetaDataProvider());

            return new MetaDataBuilder(entityParser);
        }
Example #9
0
        public void TestDbContextFile()
        {
            var filePath = Utils.GetDbContextType();

            var parser = new EntityParser(filePath);
            var result = parser.ParseToString();

            Utils.WriteResultInDebug(result);

            Assert.True(string.IsNullOrWhiteSpace(result));
        }
Example #10
0
        public void TestEntityFile()
        {
            var filePath = Utils.GetFirstEntityFile();

            var parser = new EntityParser(filePath);
            var result = parser.ParseToString();

            Utils.WriteResultInDebug(result);

            Assert.NotNull(result);
        }
        public void EntityParser_ParseEntity_WithCollectionProperties()
        {
            var code     = SampleCodeProvider.EntityWithCollectionProperties;
            var metadata = EntityParser.FromString(code);

            Assert.AreEqual(6, metadata.Properties.Count);

            Assert.IsTrue(metadata.Properties.All(p => !p.IsSimpleProperty));
            Assert.IsTrue(metadata.Properties.All(p => p.IsCollection));
            Assert.IsTrue(metadata.Properties.All(p => p.IsRelation));
            Assert.IsTrue(metadata.Properties.All(p => p.RelatedEntityName == "Something"));
        }
Example #12
0
 public ShipLoader(ILogger <ShipLoader> logger, EntityParser entityParser, IOptions <ServiceOptions> options,
                   IJsonFileReaderWriter jsonFileReaderWriter, VehicleParser vehicleParser,
                   LocalisationService localisationService, LoaderService <Manufacturer> manufacturersService)
 {
     _logger               = logger;
     _entityParser         = entityParser;
     _jsonFileReaderWriter = jsonFileReaderWriter;
     _vehicleParser        = vehicleParser;
     _localisationService  = localisationService;
     Manufacturers         = manufacturersService.Items;
     _options              = options.Value;
 }
Example #13
0
        public void DuplicateHashtagIsFoundTwice()
        {
            // Arrange
            const string text = "#test #test";

            // Act
            var hashtags = EntityParser.ExtractHashtags(text);

            // Assert
            Assert.AreEqual(2, hashtags.Count);
            Assert.IsTrue(hashtags.All(t => t.Tag == "test"));
        }
Example #14
0
 public CommodityLoader(ILogger <CommodityLoader> logger, EntityParser entityParser,
                        IJsonFileReaderWriter jsonFileReaderWriter,
                        LoaderService <CommodityTypeAndSubType> commodityTypeService,
                        IOptions <ServiceOptions> options, LocalisationService localisationService)
 {
     _logger               = logger;
     _entityParser         = entityParser;
     _jsonFileReaderWriter = jsonFileReaderWriter;
     _localisationService  = localisationService;
     CommodityTypes        = commodityTypeService.Items;
     _options              = options.Value;
 }
        public void SetHeroAvatarUnpacked(string hero, string avatar)
        {
            Logger.Log.Verbose("verbose test");

            var extractionDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());

            Directory.CreateDirectory(extractionDirectory);

            try
            {
                var heroResourcesName      = GetHeroResourcesName(hero);
                var rootResourcesDirectory = _resourcesManager.ExtractHeroResources(extractionDirectory, heroResourcesName);
                var heroResourcesDirectory = Path.Combine(rootResourcesDirectory, "heroes");
                var heroDirectoryPath      = Path.Combine(heroResourcesDirectory, heroResourcesName);
                var heroEntityPath         = GetHeroEntityPath(heroDirectoryPath, heroResourcesName);

                var heroXml = _xmlManager.GetXmlDocument(heroEntityPath);

                var heroNode       = heroXml.QuerySelector("hero");
                var avatarElements = heroNode.QuerySelectorAll("altavatar");
                var avatarKey      = GetHeroAvatarKey(hero, avatar);
                var avatarElement  = avatarElements.FirstOrDefault(a => string.Equals(a.GetAttribute("key"), avatarKey, StringComparison.InvariantCultureIgnoreCase));

                if (avatarElement == null)
                {
                    throw ThrowHelper.AvatarNotFound($"Avatar {avatar} not found for hero {hero}.", avatar);
                }

                foreach (var parser in EntityParser.GetRegisteredEntityParsers(_xmlManager))
                {
                    parser.SetEntity(heroDirectoryPath, avatarKey);
                }

                var destinationHeroDirectory = Path.Combine(_appConfiguration.HoNPath, "game", "heroes");

                Directory.CreateDirectory(destinationHeroDirectory);

                foreach (string dirPath in Directory.GetDirectories(heroResourcesDirectory, "*", SearchOption.AllDirectories))
                {
                    Directory.CreateDirectory(dirPath.Replace(heroResourcesDirectory, destinationHeroDirectory));
                }

                foreach (string newPath in Directory.GetFiles(heroResourcesDirectory, "*.*", SearchOption.AllDirectories))
                {
                    File.Copy(newPath, newPath.Replace(heroResourcesDirectory, destinationHeroDirectory), true);
                }
            }
            finally
            {
                Directory.Delete(extractionDirectory, true);
            }
        }
Example #16
0
        public ExcelReader(String fileName)
        {
            FileStream stream = new FileStream(fileName, FileMode.Open);
            workBook = WorkbookFactory.Create(stream);

            stream.Close();

            empleadoParser = new EmployeeParser();
            percepcionParser = new PercepcionParser();
            deduccionParser = new DeduccionParser();
            incapacidadParser = new IncapacidadParser();
            horasExtraParser = new HorasExtraParser();
        }
        private static IMetaDataBuilder ResolveMetaDataBuilder()
        {
            var genericTypesToMapToArray = new List <string> {
                "List`1", "IEnumerable`1"
            };

            var entityParser = new EntityParser(
                new JavascriptTypeMapper(),
                genericTypesToMapToArray,
                ResolveValidationMetaDataProvider());

            return(new MetaDataBuilder(entityParser));
        }
Example #18
0
        protected override void Initialize()
        {
            IEntityParser entityParser = new EntityParser();

            entityParser.OpenFile("../../../Data/Entities.xml");
            var entityDataCollection = entityParser.LoadEntities();

            foreach (var entityData in entityDataCollection)
            {
                var entity = _entityFactory.CreateEntity(entityData.Components);
                _entityRepository.InsertEntity(entity);
            }
        }
Example #19
0
        public void EntityParser_ParseEntity_SimplePropertiesOnly()
        {
            var code     = SampleCodeProvider.EntityOnlySimpleProperties;
            var metadata = EntityParser.FromString(code);

            Assert.AreEqual(5, metadata.Properties.Count);

            Assert.IsTrue(metadata.Properties.Any(p => p.Name == "Id" && p.IsSimpleProperty && p.Type == "int"));
            Assert.IsTrue(metadata.Properties.Any(p => p.Name == "Name" && p.IsSimpleProperty && p.Type == "string"));
            Assert.IsTrue(metadata.Properties.Any(p => p.Name == "Date" && p.IsSimpleProperty && p.Type == "DateTime?"));
            Assert.IsTrue(metadata.Properties.Any(p => p.Name == "Date2" && p.IsSimpleProperty && p.Type == "Nullable<System.DateTime>" && !p.IsCollection));
            Assert.IsTrue(metadata.Properties.Any(p => p.Name == "OtherString" && p.IsSimpleProperty && p.Type == "string"));
        }
Example #20
0
        public void TestReadInvalidEntity(string fileName)
        {
            // Given
            var invalidEntity = GetFileContents(fileName);
            var entityData    = Encoding.ASCII.GetBytes(invalidEntity);

            // When
            var parser   = new EntityParser(entityData);
            var entities = parser.Parse();

            // Then
            Assert.IsNotNull(entities);
            Assert.IsTrue(entities.Count == 0);
        }
Example #21
0
 public ItemLoader(ILogger <ItemLoader> logger, EntityParser entityParser,
                   IJsonFileReaderWriter jsonFileReaderWriter, LoaderService <Manufacturer> manufacturersService,
                   IOptions <ServiceOptions> options, LocalisationService localisationService,
                   LoaderService <Ship> shipService, LoaderService <Commodity> commodtiyService)
 {
     _logger               = logger;
     _entityParser         = entityParser;
     _jsonFileReaderWriter = jsonFileReaderWriter;
     _localisationService  = localisationService;
     Manufacturers         = manufacturersService.Items;
     Ships       = shipService.Items;
     Commodities = commodtiyService.Items;
     _options    = options.Value;
 }
Example #22
0
        public void DtoBuilder_EntityWithBase_DataAnnotations_MetadataType()
        {
            var code     = SampleCodeProvider.SampleTable3;
            var metadata = EntityParser.FromString(code);

            metadata.DtoName = "SampleTable3DTO";

            var tree = DtoBuilder.BuildDto(metadata, dtoNamespace: "Some.Namespace", addDataAnnotations: true);

            Assert.IsNotNull(tree);

            var codeText = tree.ToString();

            Assert.IsTrue(codeText.Contains("[MetadataType(typeof(SampleTable3MD))]"));
        }
Example #23
0
        public bool IsPermitted_WhenNameProvided_ExpectCorrectValue(string value)
        {
            // Arrange
            var entityParser = new EntityParser <TestEntity>();

            // Act
            var stopwatch   = Stopwatch.StartNew();
            var isPermitted = entityParser.IsPermitted(value);

            stopwatch.Stop();

            // Assert
            this.WriteTimeElapsed(stopwatch);

            return(isPermitted);
        }
Example #24
0
        public void MentionInMiddleIsExtractedCorrectly()
        {
            // Arrange
            const string text = "Hello @World how are you?";

            // Act
            var mentions = EntityParser.ExtractMentions(text);

            // Assert
            Assert.AreEqual(1, mentions.Count);

            var m = mentions.First();

            Assert.AreEqual(6, m.Start);
            Assert.AreEqual(12, m.End);
            Assert.AreEqual("World", m.ScreenName);
        }
        public static async Task <PropertySelectorViewModel> Create(Document doc, string dtoName, SolutionLocation dtoLocation, Document existingDto = null)
        {
            var autogeneratedProperties = await EntityParser.GetAutoGeneratedProperties(existingDto);

            var instance = new PropertySelectorViewModel();

            instance.EntityModel = await EntityViewModel.CreateRecursive(doc, depth : 3, existingProperties : autogeneratedProperties, canReuseBaseMapper : true);

            instance.EntityModel.DtoName = dtoName;
            instance.DtoLocation         = dtoLocation;

            var isDerived = await EntityParser.HasBaseDto(existingDto, instance.EntityModel.BaseEntityDtoName);

            instance.EntityModel.ReuseBaseEntityMapper |= isDerived;

            return(instance);
        }
Example #26
0
        public void DtoBuilder_SimpleEntityExistingDto_PropertiesAdded()
        {
            var code     = SampleCodeProvider.EntityOnlySimpleProperties;
            var metadata = EntityParser.FromString(code);

            metadata.DtoName = "EntityOnlySimplePropertiesDTO";

            var existingDtoTree = CSharpSyntaxTree.ParseText(SampleCodeProvider.EntityOnlySimplePropertiesDto);

            var tree = DtoBuilder.BuildDto(metadata, existingDto: existingDtoTree);

            Assert.IsNotNull(tree);

            var codeText = tree.ToString();

            foreach (var prop in metadata.Properties.ToList())
            {
                Assert.IsTrue(codeText.Contains($"public {prop.Type} {prop.Name} {{ get; set; }}"));
                if (prop != metadata.Properties.Last())
                {
                    Assert.IsTrue(codeText.Contains($"{prop.Name} = p.{prop.Name},"));
                }
                else
                {
                    Assert.IsTrue(codeText.Contains($"{prop.Name} = p.{prop.Name}"));
                }

                Assert.IsFalse(codeText.Contains($",{prop.Name} = p.{prop.Name}"));

                Assert.IsTrue(codeText.Contains($"model.{prop.Name} = dto.{prop.Name};"));
            }

            var customCodeBeginIdx = codeText.IndexOf("////BCC/");
            var customCodeEndIdx   = codeText.IndexOf("////ECC/");

            var customPropIdx = codeText.IndexOf("public int CustomProperty { get; set; }");
            var genPropIdx    = codeText.IndexOf("public DateTime? Date { get; set; }");

            Assert.AreNotEqual(-1, customPropIdx);
            Assert.AreNotEqual(-1, genPropIdx);
            Assert.AreNotEqual(-1, customCodeBeginIdx);
            Assert.AreNotEqual(-1, customCodeEndIdx);

            Assert.IsTrue(customPropIdx > customCodeBeginIdx && customPropIdx < customCodeEndIdx);
            Assert.IsTrue(genPropIdx > customCodeEndIdx || genPropIdx < customCodeBeginIdx);
        }
Example #27
0
        public void MentionAtEndIsCorrectlyExtracted()
        {
            // Arrange
            const string text = "This is a @test";

            // Act
            var mentions = EntityParser.ExtractMentions(text);

            // Assert
            Assert.AreEqual(1, mentions.Count);

            var m = mentions.First();

            Assert.AreEqual(10, m.Start);
            Assert.AreEqual(15, m.End);
            Assert.AreEqual("test", m.ScreenName);
        }
Example #28
0
        public void HashtagsInMiddleAreCorrectlyExtracted()
        {
            // Arrange
            const string text = "Hello #World this is a test";

            // Act
            var hashtags = EntityParser.ExtractHashtags(text);

            // Assert
            Assert.AreEqual(1, hashtags.Count);

            var tag = hashtags.First();

            Assert.AreEqual(6, tag.Start);
            Assert.AreEqual(12, tag.End);
            Assert.AreEqual("World", tag.Tag);
        }
Example #29
0
        private static CommandDefinitionModel BuildModel(InputDtoClassLocator locator)
        {
            var model = new CommandDefinitionModel();

            // set the class name to create the command with
            var className = locator.InputDtoName.Replace("InputDTO", "Command");

            model.ClassName = className;

            // parse the input class
            var entityParser   = new EntityParser();
            var entityMetadata = entityParser.Parse(locator.InputDtoNode);

            model.InputMetadata = entityMetadata;

            return(model);
        }
Example #30
0
        public ScheduleItem(SchedulerJob job, UserViewModel user, IScheduler scheduler, IConfig config, IViewServiceRepository viewServices)
            : base(config, viewServices)
        {
            Job          = job;
            User         = user;
            Scheduler    = scheduler;
            ViewServices = viewServices;

            Entities = new Entities
            {
                HashTagEntities     = EntityParser.ExtractHashtags(job.Text),
                MediaEntities       = new List <MediaEntity>(),
                SymbolEntities      = new List <SymbolEntity>(),
                UrlEntities         = new List <UrlEntity>(),
                UserMentionEntities = EntityParser.ExtractMentions(job.Text)
            };
        }
Example #31
0
        public void HashtagAtStartIsCorrectlyExtracted()
        {
            // Arrange
            const string text = "#Hello World!";

            // Act
            var hashtags = EntityParser.ExtractHashtags(text);

            // Assert
            Assert.AreEqual(1, hashtags.Count);

            var tag = hashtags.First();

            Assert.AreEqual(0, tag.Start);
            Assert.AreEqual(6, tag.End);
            Assert.AreEqual("Hello", tag.Tag);
        }
Example #32
0
        public void MentionAtStartIsCorrectlyExtracted()
        {
            // Arrange
            const string text = "@username Hello";

            // Act
            var mentions = EntityParser.ExtractMentions(text);

            // Assert
            Assert.AreEqual(1, mentions.Count);

            var m = mentions.First();

            Assert.AreEqual(0, m.Start);
            Assert.AreEqual(9, m.End);
            Assert.AreEqual("username", m.ScreenName);
        }
        public Parsers()
        {
            // Create inline parsers
            LineBreakParser = new LineBreakParser();
            BacktickParser = new BacktickParser();
            InlineCodeParser = new InlineCodeParser();
            EscapedCharParser = new EscapedCharParser();
            EntityParser = new EntityParser();
            StrWithEntitiesParser = new StrWithEntitiesParser(this);
            EscapedStringParser = new EscapedStringParser(this);
            AutolinkParser = new AutolinkParser(this);
            AutolinkEmailParser = new AutolinkEmailParser(this);
            RawHtmlParser = new RawHtmlParser();
            LinkLabelParser = new LinkLabelParser(this);
            LinkDestinationParser = new LinkDestinationParser(this);
            LinkTitleParser = new LinkTitleParser(this);
            LinkReferenceParser = new LinkReferenceParser(this);
            LinkParser = new LinkParser(this);
            ImageParser = new ImageParser(this);
            ImageReferenceParser = new ImageReferenceParser(this);
            LinkDefinitionParser = new LinkDefinitionParser(this);
            EmphasisParser = new EmphasisParser(this);
            InlineParser = new InlineParser(this);
            CommonMarkInlineParser = new CommonMarkInlineParser(this);

            // Create block parsers
            IndentedCodeParser = new IndentedCodeParser();
            LazyParagraphContinuationParser = new LazyParagraphContinuationParser();
            BlockQuoteParser = new BlockQuoteParser();
            ATXHeaderParser = new ATXHeaderParser();
            FencedCodeParser = new FencedCodeParser();
            HtmlBlockParser = new HtmlBlockParser();
            SetExtHeaderParser = new SetExtHeaderParser();
            HorizontalRuleParser = new HorizontalRuleParser();
            ListParser = new ListParser();
        }
Example #34
0
		public void findNullTextures ()
		{
				//make a list of textures that need to be loaded from wad files
				TexInfoClass[] texinfo = new TexInfoClass[NumTexLoadFromWad];
				//iterate miptexLump and add a TexInfoClass for each null texture we need to load
				int IndexOfTexinfo = 0;
		
				for (int j=0; j<miptexLump.Length; j++)//!!!!!!!!!! do this in the load miptexLump method instead!!!!!!!!!!!!!!!!!!
				{
						if (miptexLump [j].texture == null)
						{
								texinfo [IndexOfTexinfo] = new TexInfoClass (miptexLump [j].name, j);
								IndexOfTexinfo++;
						}
				}
				//next get the string of  wads we need
				string[] wadFileNames;
				myParser = new EntityParser (entityLump.rawEntities);
				
				Dictionary<string, string> mylist = myParser.ReadEntity ();
				string tempString;
				if (mylist.ContainsKey ("wad"))
				{
						tempString = mylist ["wad"];
						
						wadFileNames = tempString.Split (';');
						for (int i =0; i<wadFileNames.Length; i++)
						{
								wadFileNames [i] = wadFileNames [i].Substring (wadFileNames [i].LastIndexOf ("\\") + 1);//remove unwanted text
								if (wadFileNames [i].Length > 3)
								{
										Debug.Log (wadFileNames [i].ToString ());
										LoadTextureFromWad (wadFileNames [i], texinfo);
								}
						}
				}
				else
				{
						Debug.Log ("no textures to load from wad, or no wad key found in bsp");
				}
		}