public virtual void RunModel() { QueryModel model = new QueryModel(_workspace, _kind, null); ModelEngine engine = new ModelEngine(model); engine.Options.WeightScheme = WeightScheme.Custom; engine.Options.Timeout = 100; engine.RunUntil(delegate() { return model.Actions.Accessed > 5; }); _query = model.QueryResult; _container = model.ResContainer; _pType = model.ResultType; if (_query != null || _pType != null) { switch (_queryType) { case "server": VerifyServer(_query); break; case "client": VerifyClient(model); break; case "linq": VerifyClientLinq(model); break; } } }
//Constructor public PredicateModel(Workspace w,ResourceContainer container, ResourceProperty p, KeyExpression parentKey, ResourceType resType) { _resourceContainer = container; _workspace = w; _resType = resType; _key = parentKey; _prop = p; }
public static string ConstructETag(ResourceContainer container, IDictionary<string, object> propertyValues) { ResourceType type = container.BaseType; List<NodeProperty> etagProperties = type.Properties.Where(p => p.Facets.ConcurrencyModeFixed).ToList(); string[] etagValues = etagProperties.Select(p => PrimitiveToETagString(propertyValues[p.Name])).ToArray(); return ConstructETag(etagValues); }
void SortResourceItems(ResourceContainer resourceContainer) { resourceContainer.ResourceItems.CollectionChanged -= OnResourceItemsChanged; var resourceItems = resourceContainer.ResourceItems.OrderBy(ResourceItemKey).ToList(); resourceContainer.ResourceItems.Clear(); resourceItems.ForEach(resourceContainer.ResourceItems.Add); resourceContainer.ResourceItems.CollectionChanged += OnResourceItemsChanged; }
public void CreateIQuerableGetProperty(ResourceContainer container) { string baseType = container.BaseType.Name; this.WriteLines( " public IQueryable<" + baseType + "> " + container.Name, " {", " get", " {", " return EntitySetDictionary.GetEntitySet<" + baseType + ">();", " }", " }" ); }
public void Initialize(ScreenLayer initialLayer = null) { ResourceContainer = new AssemblyResourceContainer(Assembly.GetEntryAssembly(), $"{nameof(StorybrewEditor)}.Resources", "resources"); DrawState.Initialize(ResourceContainer, Window.Width, Window.Height); drawContext = new DrawContext(); drawContext.Register(this, false); drawContext.Register <TextureContainer>(new TextureContainerAtlas(ResourceContainer), true); drawContext.Register <QuadRenderer>(new QuadRendererBuffered(), true); drawContext.Register <LineRenderer>(new LineRendererBuffered(), true); try { var brewLibAssembly = Assembly.GetAssembly(typeof(Drawable)); Skin = new Skin(drawContext.Get <TextureContainer>()) { ResolveDrawableType = (drawableTypeName) => brewLibAssembly.GetType($"{nameof(BrewLib)}.{nameof(BrewLib.Graphics)}.{nameof(BrewLib.Graphics.Drawables)}.{drawableTypeName}", true, true), ResolveWidgetType = (widgetTypeName) => Type.GetType($"{nameof(StorybrewEditor)}.{nameof(UserInterface)}.{widgetTypeName}", false, true) ?? brewLibAssembly.GetType($"{nameof(BrewLib)}.{nameof(UserInterface)}.{widgetTypeName}", true, true), ResolveStyleType = (styleTypeName) => Type.GetType($"{nameof(StorybrewEditor)}.{nameof(UserInterface)}.{nameof(UserInterface.Skinning)}.{nameof(UserInterface.Skinning.Styles)}.{styleTypeName}", false, true) ?? brewLibAssembly.GetType($"{nameof(BrewLib)}.{nameof(UserInterface)}.{nameof(UserInterface.Skinning)}.{nameof(UserInterface.Skinning.Styles)}.{styleTypeName}", true, true), }; Skin.Load("skin.json", ResourceContainer); } catch (Exception e) { Trace.WriteLine($"Failed to load skin: {e}"); Skin = new Skin(drawContext.Get <TextureContainer>()); } var inputDispatcher = new InputDispatcher(); InputManager = new InputManager(Window, inputDispatcher); ScreenLayerManager = new ScreenLayerManager(Window, clock, this); inputDispatcher.Add(createOverlay(ScreenLayerManager)); inputDispatcher.Add(ScreenLayerManager.InputHandler); Restart(initialLayer); Window.Resize += window_Resize; Window.Closing += window_Closing; resizeToWindow(); }
public void ParseFailureApplicationNameBlank(BizTalkApplicationParser parser, ILogger logger, MigrationContext context, AzureIntegrationServicesModel model, ParsedBizTalkApplicationGroup group, Exception e) { "Given a model" .x(() => { model = new AzureIntegrationServicesModel(); group = new ParsedBizTalkApplicationGroup(); model.MigrationSource.MigrationSourceModel = group; group.Applications.Add(new ParsedBizTalkApplication() { ResourceContainerKey = "TestMsi.Key", }); model.MigrationSource.MigrationSourceModel = group; var msiContainer = new ResourceContainer() { Key = "TestMsi.Key", Name = "TestMsi", Type = ModelConstants.ResourceContainerMsi, ContainerLocation = @"C:\Test\Test.msi" }; model.MigrationSource.ResourceContainers.Add(msiContainer); var adf = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ApplicationDefinition xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"http://Microsoft.BizTalk.ApplicationDeployment/ApplicationDefinition.xsd\"> <Properties> <Property Name=\"DisplayName\" Value=\"\" /> <Property Name=\"Guid\" Value=\"{319AC06C-0FAB-4B68-B2C9-2659DF322B63}\" /> <Property Name=\"Manufacturer\" Value=\"Generated by BizTalk Application Deployment\" /> <Property Name=\"Version\" Value=\"1.0.0.0\" /> <Property Name=\"ApplicationDescription\" Value=\"BizTalk Application 1\" /> </Properties> <Resources> <Resource Type=\"System.BizTalk:BizTalkBinding\" Luid=\"Application/SimpleMessagingApplication\"> <Properties> <Property Name=\"IsDynamic\" Value=\"True\" /> <Property Name=\"IncludeGlobalPartyBinding\" Value=\"True\" /> <Property Name=\"ShortCabinetName\" Value=\"ITEM~0.CAB\" /> <Property Name=\"FullName\" Value=\"BindingInfo.xml\" /> <Property Name=\"Attributes\" Value=\"Archive\" /> <Property Name=\"CreationTime\" Value=\"2020-04-06 16:47:47Z\" /> <Property Name=\"LastAccessTime\" Value=\"2020-04-06 16:47:47Z\" /> <Property Name=\"LastWriteTime\" Value=\"2020-04-06 16:47:47Z\" /> </Properties> <Files> <File RelativePath=\"BindingInfo.xml\" Key=\"Binding\" /> </Files> </Resource> </Resources> <References> <Reference Name=\"BizTalk.System\" /> <Reference Name=\"Simple Referenced Application\" /> </References></ApplicationDefinition>"; var resource = new ResourceDefinition() { Key = "ApplicationDefinition.adf.Key", Name = "ApplicationDefinition.adf", Type = ModelConstants.ResourceDefinitionApplicationDefinition, ResourceContent = adf }; msiContainer.ResourceDefinitions.Add(resource); group.Applications[0].Application.ApplicationDefinition = new ApplicationDefinitionFile(msiContainer.Key, resource.Key); }); "And a logger" .x(() => logger = _mockLogger.Object); "And a context" .x(() => context = new MigrationContext()); "And a parser" .x(() => parser = new BizTalkApplicationParser(model, context, logger)); "When parsing" .x(() => e = Record.Exception(() => parser.Parse())); "Then the parser should not throw an exception" .x(() => e.Should().BeNull()); "And the context should have an error." .x(() => context.Errors.Count.Should().Be(1)); }
static void Main(string[] args) { Background = Color.Black; Static = new Color(52, 73, 94); Foreground = new Color(253, 227, 167); Engine.Initialize <SfmlRenderer, IrrKlangModule.IrrKlangAudioModule>(); Engine.EventHost.RegisterEvent <KeyDownEvent>((int)Keyboard.Key.Escape, 0, (ev) => { while (Engine.SceneHost.CurrentScene != null) { Engine.SceneHost.Pop(); } }); Engine.EventHost.RegisterEvent <InitializeEvent>(0, (ev) => { Engine.DesiredResolution = new Vector2(640f, 480f); Container = Engine.ResourceHost.LoadDictionary("main", "Resources"); Font12 = LoadFont("Fonts/merriweather_12.fnt"); Font16 = LoadFont("Fonts/merriweather_16.fnt"); Logo = LoadTexture("logo.png"); Player = LoadTexture("player.png"); Portal = LoadTexture("portal.png"); Hint1 = LoadTexture("hint1.png"); Hint2 = LoadTexture("hint2.png"); Hint3 = LoadTexture("hint3.png"); EndScreen = LoadTexture("endscreen.png"); Music = LoadSound("music.wav"); EnemyHit = LoadSound("ehit.wav"); Cut = LoadSound("cut.wav"); Ground = LoadSound("ground.wav"); Music.Loop(); Image image = new Image(1, 1); image.SetColor(0, 0, Color.White); Pixel = Engine.Renderer.TextureFromImage(image); var scene = Engine.SceneHost.CreateGlobal <MainScene>(); Engine.SceneHost.Push(scene); }); Engine.StartGame("cut", WindowStyle.Default); }
private void ShowPantry(Transform visualizationRoot, ResourceContainer sumContainer) { float meals = sumContainer.CurrentAmount * sumContainer.MatterType.UnitsPerCubicMeter(); for (int i = 0; i < visualizationRoot.childCount; i++) { visualizationRoot.GetChild(i).gameObject.SetActive(meals >= i + 1); } Collider c = visualizationRoot.GetComponent <Collider>(); if (c != null) { c.enabled = meals > 0f; } }
private void InitResourceContainer(GameObject go, Vector3Int cellPosition) { Transform interactor = go.transform.Find("interactor"); if (interactor) { ResourceContainer container = interactor.GetComponent <ResourceContainer>(); if (container && persistantData.resourceContainersSave.ContainsKey(cellPosition)) { foreach (KeyValuePair <string, int> entry in persistantData.resourceContainersSave[cellPosition]) { container.AddItem(entry.Key, entry.Value); } } } }
public static void Copy(ResourceContainer source, ResourceContainer destination) { destination.useResourceMaterial = source.useResourceMaterial; destination.capacity = source.capacity; destination.groupSize = source.groupSize; foreach (string s in source.acceptedResources) { destination.acceptedResources.Add(s); } foreach (KeyValuePair <string, int> entry in source.inventory) { destination.inventory.Add(entry.Key, entry.Value); } destination.UpdateContent(); }
public override QueryNode GetClientLinqQueryNode() { ResourceContainer resourceContainer = this.Path.ResourceContainer.ResourceContainer; QueryNode query = this.Path.GetClientLinqQueryNode(); if (this.Options != null) { foreach (QueryOption queryOption in this.Options) { switch (queryOption.Name) { case "$select": query = query.Select(query.New(GetProperties(queryOption.Value, resourceContainer))); break; case "$filter": query = query.Where(ProcessFilter(queryOption.Value, resourceContainer)); break; case "$orderby": // ascending/descending not supported query = query.Sort(GetProperties(queryOption.Value, resourceContainer), true); break; case "$expand": query = query.Expand(GetProperties(queryOption.Value, resourceContainer)); break; case "$inlinecount": query = query.Count(true); break; case "$top": query = query.Top(int.Parse(queryOption.Value)); break; case "$skip": query = query.Skip(int.Parse(queryOption.Value)); break; default: throw new NotSupportedException(string.Format("queryOption: {0} (value: {1}) is invalid or not supported.", queryOption.Name, queryOption.Value)); } } } return(query); }
public void ParseFailureEmptyXml(ApplicationDefinitionParser parser, ILogger logger, MigrationContext context, AzureIntegrationServicesModel model, ParsedBizTalkApplicationGroup group, Exception e) { "Given a model" .x(() => { model = new AzureIntegrationServicesModel(); group = CreateGroup(); model.MigrationSource.MigrationSourceModel = group; var container = new ResourceContainer() { Key = "Test.Key", Name = "Test", Type = ModelConstants.ResourceContainerCab, ContainerLocation = @"C:\Test\Test.CAB" }; model.MigrationSource.ResourceContainers.Add(container); var adf = string.Empty; var resource = new ResourceDefinition() { Key = "Test.adf.Key", Name = "Test.adf", Type = ModelConstants.ResourceDefinitionApplicationDefinition, ResourceContent = adf }; container.ResourceDefinitions.Add(resource); group.Applications[0].Application.ApplicationDefinition = new ApplicationDefinitionFile(container.Key, resource.Key); }); "And a logger" .x(() => logger = _mockLogger.Object); "And a context" .x(() => context = new MigrationContext()); "And a parser" .x(() => parser = new ApplicationDefinitionParser(model, context, logger)); "When parsing" .x(() => e = Record.Exception(() => parser.Parse())); "Then the code should not throw an exception" .x(() => e.Should().BeNull()); "And the parser should have recorded an error when processing the filter." .x(() => { var item = group.Applications[0].Application.ApplicationDefinition.ApplicationDefinition.Should().BeNull(); context.Errors.Count.Should().Be(1); }); }
static void Main(string[] args) { Background = Color.Black; Static = new Color(52, 73, 94); Foreground = new Color(253, 227, 167); Engine.Initialize<SfmlRenderer, IrrKlangModule.IrrKlangAudioModule>(); Engine.EventHost.RegisterEvent<KeyDownEvent>((int)Keyboard.Key.Escape, 0, (ev) => { while (Engine.SceneHost.CurrentScene != null) Engine.SceneHost.Pop(); }); Engine.EventHost.RegisterEvent<InitializeEvent>(0, (ev) => { Engine.DesiredResolution = new Vector2(640f, 480f); Container = Engine.ResourceHost.LoadDictionary("main", "Resources"); Font12 = LoadFont("Fonts/merriweather_12.fnt"); Font16 = LoadFont("Fonts/merriweather_16.fnt"); Logo = LoadTexture("logo.png"); Player = LoadTexture("player.png"); Portal = LoadTexture("portal.png"); Hint1 = LoadTexture("hint1.png"); Hint2 = LoadTexture("hint2.png"); Hint3 = LoadTexture("hint3.png"); EndScreen = LoadTexture("endscreen.png"); Music = LoadSound("music.wav"); EnemyHit = LoadSound("ehit.wav"); Cut = LoadSound("cut.wav"); Ground = LoadSound("ground.wav"); Music.Loop(); Image image = new Image(1, 1); image.SetColor(0, 0, Color.White); Pixel = Engine.Renderer.TextureFromImage(image); var scene = Engine.SceneHost.CreateGlobal<MainScene>(); Engine.SceneHost.Push(scene); }); Engine.StartGame("cut", WindowStyle.Default); }
public void Execute(object sender, ResourceEventArgs es) { if (!ChangeEnabledStateEventHandler(sender, es)) { return; } SimPe.Events.ResourceContainers c = new ResourceContainers(); foreach (SimPe.Interfaces.Files.IPackedFileDescriptor pfd in es.LoadedPackage.Package.Index) { SimPe.Interfaces.Scenegraph.IScenegraphFileIndexItem fii = new SimPe.Plugin.FileIndexItem(pfd, es.LoadedPackage.Package); SimPe.Events.ResourceContainer rc = new ResourceContainer(fii); c.Add(rc); } CreateListFromSelectionTool.Execute(c); }
private JObject loadJson(string filename, ResourceContainer resourceContainer) { byte[] data; if (File.Exists(filename)) { data = File.ReadAllBytes(filename); } else { data = resourceContainer?.GetBytes(filename); } if (data == null) { throw new FileNotFoundException(filename); } return(resolveIncludes(data.ToJObject(), resourceContainer)); }
private ResourceItem FindResourceItem(RegroupToResourceCommand.ConvertibleBrushReference brushReference) { ResourceContainer resourceContainer = this.designerContext.ResourceManager.FindResourceContainer(brushReference.DocumentUrl); if (resourceContainer != null) { foreach (ResourceItem resourceItem in (Collection <ResourceItem>)resourceContainer.ResourceItems) { ResourceEntryItem resourceEntryItem = resourceItem as ResourceEntryItem; if (resourceEntryItem != null && DocumentPrimitiveNode.GetValueAsString(resourceEntryItem.Resource.KeyNode) == brushReference.Key) { return((ResourceItem)resourceEntryItem); } } } return((ResourceItem)null); }
internal AudioStream(AudioManager manager, string path, ResourceContainer resourceContainer) : base(manager) { this.path = path; decodeStream = Bass.CreateStream(path, 0, 0, BassFlags.Decode | BassFlags.Prescan); if (decodeStream == 0) { Trace.WriteLine($"Failed to load audio stream ({path}): {Bass.LastError}"); return; } stream = BassFx.TempoCreate(decodeStream, BassFlags.Default); Bass.ChannelSetAttribute(stream, ChannelAttribute.TempoUseQuickAlgorithm, 1); Bass.ChannelSetAttribute(stream, ChannelAttribute.TempoOverlapMilliseconds, 4); Bass.ChannelSetAttribute(stream, ChannelAttribute.TempoSequenceMilliseconds, 30); Channel = stream; }
private JObject resolveIncludes(JObject data, ResourceContainer resourceContainer) { if (data["include"] != null) { var snapshot = new List <JToken>(data["include"]); foreach (var include in snapshot) { var path = include.Value <string>(); var includedData = loadJson(path, resourceContainer); data.Merge(includedData, new JsonMergeSettings() { MergeArrayHandling = MergeArrayHandling.Union, MergeNullValueHandling = MergeNullValueHandling.Merge, }); } } return(data); }
public static KeyExpression ConstructKey(ResourceContainer container, PayloadObject entity) { Dictionary<string, object> properties = new Dictionary<string, object>(); ResourceType type = container.BaseType; if (entity.Type != type.Namespace + "." + type.Name) { type = container.ResourceTypes.SingleOrDefault(rt => rt.Namespace + "." + rt.Name == entity.Type); if (type == null) AstoriaTestLog.FailAndThrow("Could not find resource type for payload type value: " + entity.Type); } foreach (ResourceProperty property in type.Properties.OfType<ResourceProperty>()) { if (property.IsNavigation || property.IsComplexType) continue; string propertyName = property.Name; string valueString; if (entity.PayloadProperties.Any(p => p.Name == propertyName)) { PayloadSimpleProperty simpleProperty = entity[propertyName] as PayloadSimpleProperty; if (simpleProperty == null) continue; valueString = simpleProperty.Value; } else { continue; } object value = CommonPayload.DeserializeStringToObject(valueString, property.Type.ClrType, false, entity.Format); if (value is DateTime && entity.Format == SerializationFormatKind.JSON) { // TODO: this is because the server will make any JSON datetime into UTC, and currently we always send 'unspecified' values value = new DateTime(((DateTime)value).Ticks, DateTimeKind.Unspecified); } properties[propertyName] = value; } return new KeyExpression(container, type, properties); }
public GameObject GetResourcePile(Dictionary <string, int> ressourcesList) { GameObject pile = Instantiate(resourcePilePrefab); pile.name = "ResourcePile"; pile.transform.rotation = Quaternion.Euler(0, Random.Range(0, 4) * 90f, 0); pile.transform.localScale = Vector3.one; ResourceContainer pileContainer = pile.transform.Find("interactor").gameObject.GetComponent <ResourceContainer>(); pileContainer.capacity = 0; foreach (KeyValuePair <string, int> entry in ressourcesList) { pileContainer.AddItem(entry.Key, entry.Value); } pileContainer.UpdateContent(); return(pile); }
private void OnResourceChange(params Matter[] type) { ResourceContainer container = this.LinkedHab.Get(Matter.Biomass); float meals = container.CurrentAmount * container.MatterType.UnitsPerCubicMeter(); for (int i = 0; i < BiomassStorageRoot.childCount; i++) { BiomassStorageRoot.GetChild(i).gameObject.SetActive(meals >= i + 1); } BiomassVisualization.gameObject.SetActive(meals > 0f); container = this.LinkedHab.Get(Matter.MealPowders); float powders = container.CurrentAmount * container.MatterType.UnitsPerCubicMeter(); this.PowderVisualization.gameObject.SetActive(powders > 0f); }
public void Save(ResourceContainer container, Vector3Int position) { if (container.inventory.Count != 0) { if (!resourceContainersSave.ContainsKey(position)) { resourceContainersSave.Add(position, new Dictionary <string, int>()); } resourceContainersSave[position].Clear(); foreach (KeyValuePair <string, int> entry in container.inventory) { resourceContainersSave[position].Add(entry.Key, entry.Value); } } else if (resourceContainersSave.ContainsKey(position)) { resourceContainersSave.Remove(position); } }
public void FindSource() { Debug.Log("Looking for Mine!"); GameObject[] resources = GameObject.FindGameObjectsWithTag("Mine"); Debug.Log("Options:" + resources.Length); GameObject mine = null; float min_score = float.MaxValue; foreach (GameObject resource in resources) { if (resource.GetComponent <Unit>().team != GetComponent <Unit>().team) { continue; } float dist = (transform.position - resource.transform.position).magnitude; int metal = resource.GetComponent <ResourceContainer>().metal; if (metal == 0) { metal = 1; } float score = dist * (1 / metal); if (score <= min_score) { min_score = score; mine = resource; } } if (mine == null) { return; } ResourceContainer cont = mine.GetComponent <ResourceContainer>(); cont._po_points_idx = (cont._po_points_idx + 1) / cont._pick_off_points.Length; Transform source = cont._pick_off_points[cont._po_points_idx]; _mov.SetDestination(source.position, source.rotation); }
private bool EnsureDataSourceReachable(SceneNode targetNode, DataSourceNode dataSource) { if (!targetNode.ViewModel.Document.HasOpenTransaction || new ExpressionEvaluator(targetNode.ViewModel.DocumentRootResolver).EvaluateResource(targetNode.DocumentNodePath, ResourceReferenceType.Static, dataSource.ResourceKey) != null) { return(true); } IProjectDocument projectDocument = targetNode.ProjectContext.OpenDocument(dataSource.DocumentNode.Context.DocumentUrl); if (projectDocument == null || projectDocument.DocumentType != ProjectDocumentType.ResourceDictionary) { return(false); } SceneDocument resourceDictionary1 = projectDocument.Document as SceneDocument; ResourceManager resourceManager = targetNode.ViewModel.DesignerContext.ResourceManager; ResourceDictionaryContentProvider resourceDictionary2 = resourceManager.FindContentProviderForResourceDictionary(resourceDictionary1); ResourceContainer resourceContainer = resourceManager.FindResourceContainer(targetNode.DocumentContext.DocumentUrl); return(resourceDictionary2.EnsureLinked(targetNode.ViewModel, resourceContainer)); }
} // для структур, имеющих влияние на другие блоки; сообщает, что одна секция отвалилась // в финальном виде копипастить в потомков protected bool PrepareStructureForDestruction(bool forced) { if (forced) { UnsetBasement(); } else { ResourceContainer[] resourcesLeft = ResourcesCost.GetCost(id); if (resourcesLeft.Length > 0 & GameMaster.demolitionLossesPercent != 1) { for (int i = 0; i < resourcesLeft.Length; i++) { resourcesLeft[i] = new ResourceContainer(resourcesLeft[i].type, resourcesLeft[i].volume * (1 - GameMaster.demolitionLossesPercent)); } GameMaster.colonyController.storage.AddResources(resourcesLeft); } } if (!forced & (basement != null)) { basement.RemoveStructure(this); if (subscribedToChunkUpdate) { basement.myChunk.ChunkUpdateEvent -= ChunkUpdated; subscribedToChunkUpdate = false; } SurfaceBlock lastBasement = basement; if (isBasement) { Block upperBlock = lastBasement.myChunk.GetBlock(lastBasement.pos.x, lastBasement.pos.y + 1, lastBasement.pos.z); if (upperBlock != null) { lastBasement.myChunk.DeleteBlock(upperBlock.pos); } } return(true); } else { return(false); } }
private void ToolStripButtonNew_Click(object sender, EventArgs e) { var message = "You are about to create a new resource." + Environment.NewLine + Environment.NewLine + "All existing changes will be discarded." + Environment.NewLine + Environment.NewLine + "Are you sure you want to continue?"; var result = MessageBox.Show(this, message, Application.ProductName, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2); if (result == DialogResult.Yes) { this.ResourceContainer = new ResourceContainer(); this.RefreshData(); } }
public void UpdateTakeFromSource() { #region Setup var mockComponentActorFactory = new Mock <ComponentActorFactory <TransportableStorage> >(Sys); mockComponentActorFactory.Setup(f => f.GetProps(It.IsAny <TransportableStorage>())) .Returns(Props.Create(() => new EntityTestActor())); var sourceEntity = new Entity(); var resourceContainer = new ResourceContainer(); var sourceTransporter = new TransportableStorage(); // TODO: Entity might not be needed var containerEntity = new Entity { resourceContainer, new Transportable { Transporter = sourceTransporter } }; var orderTargetTransportable = new TransportableStorage(); var orderTargetEntity = new Entity { orderTargetTransportable }; var deliverOrder = new DeliverContainerToStorage(resourceContainer, orderTargetEntity, mockComponentActorFactory.Object); var transporterStorage = new TransportableStorage(); var transporterEntity = new Entity { transporterStorage }; #endregion deliverOrder.Update(transporterEntity, new GameTime()); var messageToEntityComponent = ExpectMsg <MessageToEntityComponentFirstOfType <TransportableStorage> >(); Assert.Equal(sourceEntity.Id, messageToEntityComponent.EntityId); var giveTransportableTo = Assert.IsType <GiveTransportableTo>(messageToEntityComponent.Message); Assert.Equal(resourceContainer.Id, giveTransportableTo.Transportable.Id); Assert.Equal(transporterStorage.Id, giveTransportableTo.Target.Id); }
public static Bitmap LoadBitmap(string filename, ResourceContainer resourceContainer = null) { if (File.Exists(filename)) { return((Bitmap)Image.FromFile(filename, false)); } if (resourceContainer == null) { return(null); } using (var stream = resourceContainer.GetStream(filename)) { if (stream == null) { Trace.WriteLine($"Texture not found: {filename}"); return(null); } return((Bitmap)Image.FromStream(stream, false)); } }
private void OnResourceChange(params Matter[] type) { print("showing table contents"); ResourceContainer cont = this.LinkedHab.Get(Matter.RationMeals); if (cont != null) { RationMeal.gameObject.SetActive(cont.CurrentAmount > 0f); } cont = this.LinkedHab.Get(Matter.OrganicMeals); if (cont != null) { OrganicMeal.gameObject.SetActive(cont.CurrentAmount > 0f); } cont = this.LinkedHab.Get(Matter.MealShakes); if (cont != null) { ShakeMeal.gameObject.SetActive(cont.CurrentAmount > 0f); } }
public ScriptManager(ResourceContainer resourceContainer, string scriptsNamespace, string scriptsSourcePath, string commonScriptsPath, string scriptsLibraryPath, string compiledScriptsPath, IEnumerable <string> referencedAssemblies) { this.resourceContainer = resourceContainer; this.scriptsNamespace = scriptsNamespace; this.scriptsSourcePath = scriptsSourcePath; this.commonScriptsPath = commonScriptsPath; this.scriptsLibraryPath = scriptsLibraryPath; this.compiledScriptsPath = compiledScriptsPath; ReferencedAssemblies = referencedAssemblies; scriptWatcher = new FileSystemWatcher() { Filter = "*.cs", Path = scriptsSourcePath, IncludeSubdirectories = false, }; scriptWatcher.Created += scriptWatcher_Changed; scriptWatcher.Changed += scriptWatcher_Changed; scriptWatcher.Renamed += scriptWatcher_Changed; scriptWatcher.Deleted += scriptWatcher_Changed; scriptWatcher.Error += (sender, e) => Trace.WriteLine($"Watcher error (script): {e.GetException()}"); scriptWatcher.EnableRaisingEvents = true; Trace.WriteLine($"Watching (script): {scriptsSourcePath}"); libraryWatcher = new FileSystemWatcher() { Filter = "*.cs", Path = scriptsLibraryPath, IncludeSubdirectories = true, }; libraryWatcher.Created += libraryWatcher_Changed; libraryWatcher.Changed += libraryWatcher_Changed; libraryWatcher.Renamed += libraryWatcher_Changed; libraryWatcher.Deleted += libraryWatcher_Changed; libraryWatcher.Error += (sender, e) => Trace.WriteLine($"Watcher error (library): {e.GetException()}"); libraryWatcher.EnableRaisingEvents = true; Trace.WriteLine($"Watching (library): {scriptsLibraryPath}"); }
private void UpdateContainerViewer(ResourceContainer container) { containerViewer.SetActive(true); containerLoad.text = container.load.ToString() + "/" + container.capacity.ToString(); containerName.text = container.transform.parent.gameObject.name + ":"; if (container.inventory.Count > containersIcons.Count) { Debug.LogWarning("Not enough prefab in InteractionUI.containerViewer to assign all resources icon"); } int index = 0; foreach (KeyValuePair <string, int> entry in container.inventory) { if (ResourceDictionary.instance.resources.ContainsKey(entry.Key)) { containersIcons[index].gameObject.SetActive(true); containersIcons[index].data = ResourceDictionary.instance.resources[entry.Key]; containersIcons[index].icon.sprite = ResourceDictionary.instance.resources[entry.Key].icon; containersIcons[index].text.text = entry.Value < 1000 ? entry.Value.ToString() : (entry.Value / 1000).ToString("##.#") + "k"; index++; } else { Debug.LogWarning("Container refer to an unknown resource : " + entry.Key); } if (index >= containersIcons.Count) { break; } } for (; index < containersIcons.Count; index++) { containersIcons[index].gameObject.SetActive(false); } }
public static IModelElement CreateMediaStoreDeployment(Uri uri) { var appServer = new ResourceContainer() { Name = "Application Server" }; var computeEnvironment = new ResourceEnvironment(); computeEnvironment.Container.Add(appServer); var deployment = new MediaStore() { Environment = computeEnvironment, WebForm = appServer, AudioStore = appServer, UserManagement = appServer, OggEncoder = appServer, EncodingAdapter = appServer, DBAdapter = appServer, MySqlClient = appServer }; return(deployment); }
override public ResourceContainer[] GetUpgradeCost() { if (level < 4) { ResourceContainer[] cost = ResourcesCost.GetCost(upgradedIndex); float discount = GameMaster.upgradeDiscount; for (int i = 0; i < cost.Length; i++) { cost[i] = new ResourceContainer(cost[i].type, cost[i].volume * discount); } return(cost); } else { ResourceContainer[] cost = ResourcesCost.GetCost(HQ_4_ID); float discount = GameMaster.upgradeCostIncrease + level - 4; for (int i = 0; i < cost.Length; i++) { cost[i] = new ResourceContainer(cost[i].type, cost[i].volume * discount); } return(cost); } }
public static Project Load(string projectPath, bool withCommonScripts, ResourceContainer resourceContainer) { // Binary format isn't saved anymore and may be obsolete: // Load from the text format if possible even if the binary format has been selected. var textFormatPath = projectPath.Replace(DefaultBinaryFilename, DefaultTextFilename); if (projectPath.EndsWith(BinaryExtension) && File.Exists(textFormatPath)) { projectPath = textFormatPath; } var project = new Project(projectPath, withCommonScripts, resourceContainer); if (projectPath.EndsWith(BinaryExtension)) { project.loadBinary(projectPath); } else { project.loadText(textFormatPath); } return(project); }
private void Initialize() { var backUp = new ResourceContainer("..", new FileBrowseLink(Path.Combine(_currentPath, ".."), this)); Items.Add(backUp); // Enumerate folders and files var dirs = Directory.GetDirectories(_currentPath); // Add them to the file explorer foreach (var dir in dirs) { var dirInfo = new DirectoryInfo(dir); var resource = new ResourceContainer(dirInfo.Name, new FileBrowseLink(dir, this), IconsDescription.Folder); Items.Add(resource); dirInfo = null; } var files = Directory.GetFiles(_currentPath); // Add them to the file explorer foreach (var file in files) { var fileInfo = new FileInfo(file); if (!ValidFileTypes.Contains(fileInfo.Extension)) { continue; } var resource = new ResourceContainer(fileInfo.Name, new FileBrowseLink(file, this), IconsDescription.Runbook); Items.Add(resource); fileInfo = null; } }
public async Task ProcessAsync(IEvent @event) { var providerUpdateEvent = (IntegrationProviderUpdateEvent)@event; _logger.Information(nameof(FitbitProviderUpdateEventHandler), providerUpdateEvent.Properties); FitbitUpdateNotification fitbitUpdate = ((JObject)providerUpdateEvent.Data.ProviderData) .ToObject <FitbitUpdateNotification>(); string accessToken = await _fitbitTokenService.GetAccessTokenAsync(providerUpdateEvent.Data.UserId); ResourceContainer resource = await _fitbitClient.GetResourceAsync( ownerType : fitbitUpdate.OwnerType, ownerId : fitbitUpdate.OwnerId, collectionType : fitbitUpdate.CollectionType, date : fitbitUpdate.Date, accessToken : accessToken); if (resource.Body is null) { _logger.LogWarning($"Data mapping not supported: {JsonConvert.SerializeObject(resource)}"); return; } await _fhirClient.EnsurePatientDeviceAsync(providerUpdateEvent.Data.UserId); IoMTModel iomtModel = new BodyWeight { Weight = resource.Body.Weight, MeasurementDateTime = fitbitUpdate.Date, DeviceId = providerUpdateEvent.Data.UserId, PatientId = providerUpdateEvent.Data.UserId }; await _iomtDataPublisher.PublishAsync(iomtModel); }
private ResourceBodyTree CanonicalResourcePayload(Workspace workspace, ResourceContainer resourceContainer) { ResourceType type = resourceContainer.BaseType; // TODO: support PUT by adding key support. ResourceInstanceProperty[] keyProperties = new ResourceInstanceProperty[0]; ResourceInstanceKey keyExpression = new ResourceInstanceKey(resourceContainer,type, keyProperties); List<ResourceInstanceProperty> properties = new List<ResourceInstanceProperty>(); foreach (NodeProperty p in type.Properties) { // TODO: support to implement binding. if (p.Type is ResourceCollection) { continue; } if (p.Type is ComplexType) { continue; } properties.Add(new ResourceInstanceSimpleProperty(p.Name, p.GetSampleValue())); } KeyedResourceInstance instance = new KeyedResourceInstance(keyExpression, properties.ToArray()); return instance; }
public static KeyedResourceInstance CreateKeyedResourceInstanceByClone(ResourceContainer container, ResourceType resourceType) { return CreateKeyedResourceInstanceByClone(container, resourceType, false); }
public static KeyedResourceInstance CreateKeyedResourceInstanceByClone(ResourceContainer container, ResourceType resourceType, bool excludeRelationships) { Workspace workspace = container.Workspace; //Clone for an existing resource, and update its key KeyExpression keyExpression = workspace.GetRandomExistingKey(container, resourceType); if (keyExpression == null) return null; KeyedResourceInstance dataObject = workspace.GetSingleResourceByKey(keyExpression); if (dataObject == null) return null; ResourceInstanceKey key = null; // if there are any non-server-generated key properties, then we need to build the key if (keyExpression.ResourceType.Properties.Any(p => p.PrimaryKey != null && !p.Facets.ServerGenerated)) { ResourceType newResourceType = container.ResourceTypes.Where(rt => rt.Name == dataObject.TypeName).FirstOrDefault(); key = CreateUniqueKey(container, newResourceType); } //Foreach property in dataObject create a ResourceProperty List<ResourceInstanceProperty> properties = new List<ResourceInstanceProperty>(); properties.AddRange(dataObject.Properties.OfType<ResourceInstanceSimpleProperty>().ToArray()); properties.AddRange(dataObject.Properties.OfType<ResourceInstanceComplexProperty>().ToArray()); if (!excludeRelationships) properties.AddRange(CloneRequiredRelationships(container, keyExpression.ResourceType, keyExpression)); KeyedResourceInstance keyResourceInstance = null; if (key != null) keyResourceInstance = new KeyedResourceInstance(key, properties.ToArray()); else keyResourceInstance = new KeyedResourceInstance(dataObject.ResourceSetName, dataObject.TypeName, properties.ToArray()); return keyResourceInstance; }
public static void ExecuteLinq(Workspace workspace, ExpNode q, ResourceContainer container) { try { ExecuteLinq(workspace, q, container, false, null); } catch (Exception e) { AstoriaTestLog.FailAndContinue(e); } }
internal static ResourceInstanceKey CreateUniqueKey(ResourceContainer container, ResourceType resType, KeyExpressions relatedForeignKeys, KeyExpressions existingKeys) { KeyExpressions possibleRelatedForeignKeys = new KeyExpressions(); Workspace workspace = container.Workspace; int keysGenerated = 0; bool keyTrying = true; ResourceInstanceKey resourceInstanceKey = null; do { possibleRelatedForeignKeys = new KeyExpressions(); resourceInstanceKey = TryCreateUniqueResourceInstanceKey(container, resType, possibleRelatedForeignKeys); KeyExpression keyExpression = resourceInstanceKey.CreateKeyExpression(container, resType); // need to make sure its not a duplicate // if (existingKeys == null) { KeyedResourceInstance o = workspace.GetSingleResourceByKey(keyExpression); if (o == null) keyTrying = false; } else { keyTrying = existingKeys.Contains(keyExpression); } keysGenerated++; if (keysGenerated > 25) throw new Microsoft.Test.ModuleCore.TestFailedException("Unable to create a unique key"); } while (keyTrying); relatedForeignKeys.Add(possibleRelatedForeignKeys); return resourceInstanceKey; }
public static string ConstructETag(ResourceContainer container, PayloadObject entity) { KeyExpression key = ConstructKey(container, entity); return key.ETag; }
public KeyedResourceInstance CreateRandomResource(ResourceContainer container, bool populateNavProps) { return CreateRandomResource(container, null, populateNavProps); }
public KeyedResourceInstance CreateRandomResource(ResourceContainer container, KeyExpressions existingKeys) { return CreateRandomResource(container, existingKeys, true); }
private static List<ResourceInstanceProperty> CloneRequiredRelationships(ResourceContainer container, ResourceType resourceType, KeyExpression keyExpression) { List<ResourceInstanceProperty> properties = new List<ResourceInstanceProperty>(); //Foreach Navigation Property in dataObject create a bind Dictionary<ResourceProperty, KeyExpressions> navigationProperties = GetAllAssociatedKeys(container, resourceType, keyExpression); foreach (ResourceProperty navProperty in navigationProperties.Keys) { //ResourceAssociationEnd otherEnd = navProperty.ResourceAssociation.GetOtherEnd(navProperty); ResourceType navPropertyResourceType = (navProperty.Type is CollectionType ? (navProperty.Type as CollectionType).SubType : navProperty.Type) as ResourceType; ResourceContainer otherContainer = container.FindDefaultRelatedContainer(navProperty); bool foreignKeyViolation = false; foreach (ResourceProperty otherProperty in otherContainer.BaseType.Key.Properties) { if (otherProperty.ForeignKeys.Count() > 0) { ResourceType otherType = otherProperty.ForeignKeys.First().PrimaryKey.Properties.OfType<ResourceProperty>().First().ResourceType; if (otherType == container.BaseType) { foreignKeyViolation = true; break; } } } if (foreignKeyViolation) continue; KeyExpressions keyExpressions = navigationProperties[navProperty]; if (navProperty.Type is ResourceType) { if (keyExpressions.Count > 0) { properties.Add(CreateRefInstanceProperty(keyExpressions[0], otherContainer, navProperty)); } } else { ResourceInstanceProperty property = CreateCollectionInstanceProperty(keyExpressions, otherContainer, navProperty); if (property != null) { properties.Add(property); } } } return properties; }
public KeyedResourceInstance CreateRandomResource(ResourceContainer container) { return CreateRandomResource(container, true); }
public static Dictionary<ResourceProperty, KeyExpressions> GetAllAssociatedKeys(ResourceContainer container, ResourceType resourceType, KeyExpression keyExpression) { Workspace workspace = container.Workspace; Dictionary<ResourceProperty, KeyExpressions> listOfKeyExpressions = new Dictionary<ResourceProperty, KeyExpressions>(); foreach (ResourceProperty resourceProperty in resourceType.Properties) { if (resourceProperty.IsNavigation) { KeyExpressions keys = workspace.GetExistingAssociatedKeys(container, resourceProperty, keyExpression); listOfKeyExpressions.Add(resourceProperty, keys); } } return listOfKeyExpressions; }
internal static KeyedResourceInstance CreateKeyedResourceInstanceByExactClone(ResourceContainer container, ResourceType resourceType, object dataObject) { List<ResourceInstanceProperty> properties = new List<ResourceInstanceProperty>(); List<ResourceInstanceProperty> keyProperties = new List<ResourceInstanceProperty>(); properties.AddRange(CloneObjectToResourceInstanceProperties(resourceType.Properties.OfType<ResourceProperty>().Where(rp => rp.PrimaryKey == null && rp.IsNavigation == false), dataObject)); keyProperties.AddRange(CloneObjectToResourceInstanceProperties(resourceType.Properties.OfType<ResourceProperty>().Where(rp => rp.PrimaryKey != null && rp.IsNavigation == false), dataObject)); ResourceInstanceKey key = new ResourceInstanceKey(container, resourceType, keyProperties.ToArray()); KeyedResourceInstance keyResourceInstance = new KeyedResourceInstance(key, properties.ToArray()); return keyResourceInstance; }
public virtual void DirectedTests() { QueryModel model = new QueryModel(_workspace, SerializationFormatKind.Atom, null); ModelEngine engine = new ModelEngine(model); engine.Options.WeightScheme = WeightScheme.Custom; engine.Options.Timeout = 100; engine.RunUntil(delegate() { return engine.Models.Actions.AllCovered; }); //engine.RunScenario(model.Actions.Find("From", "Where", " Navigation","Select","Expand")); //engine.RunUntil(delegate() //{ // return model.Actions.Accessed > 4; //}); _query = model.QueryResult; _container = model.ResContainer; _pType = model.ResultType; if (_query != null || _pType != null) { VerifyClient(model); } }
public override IQueryable ResourceContainerToQueryable(ResourceContainer container) { //Get Lts Type Type type = this._resourceTypeToWorkspaceTypeList[container.BaseType]; DataContext context = new DataContext(this.Database.DatabaseConnectionString); MethodInfo method = context.GetType().GetMethod("GetTable", new Type[] { }); MethodInfo genMethod = method.MakeGenericMethod(new Type[] { type }); object o = genMethod.Invoke(context, new object[] { }); if (container.HasInterceptorExpression) { o = ApplyQueryInterceptorExpression(container, o as IQueryable); } return (IQueryable)o; }
internal KeyedResourceInstance CreateRandomResource(ResourceContainer container, KeyExpressions existingKeys, bool populateNavProps) { KeyExpressions relatedForeignKeys = new KeyExpressions(); ResourceInstanceKey key = ResourceInstanceUtil.CreateUniqueKey(container, this, relatedForeignKeys, existingKeys); List<ResourceInstanceProperty> properties = new List<ResourceInstanceProperty>(); // populate the non-key, non-navigation properties // foreach (ResourceProperty p in this.Properties.OfType<ResourceProperty>().Where(rp => rp.IsNavigation == false && rp.PrimaryKey == null)) { if (p.Facets.IsIdentity) continue; ResourceInstanceProperty property = p.CreateRandomResourceInstanceProperty(); properties.Add(property); } if (populateNavProps) { // populate the navigation properties, but don't go by key, as some foreign keys MAY NOT HAVE ASSOCIATED NAVIGATION PROPERTIES // foreach (ResourceProperty p in this.Properties.OfType<ResourceProperty>().Where(rp => rp.IsNavigation)) { // find a key for this navigation property KeyExpression navPropKey = null; foreach (KeyExpression keyExp in relatedForeignKeys) { //if (p.Type.Equals(keyExp.ResourceType) // || p.Type is ResourceType && (p.Type as ResourceType).BaseTypes.Contains(keyExp.ResourceType)) if (p.OtherAssociationEnd.ResourceType.Equals(keyExp.ResourceType)) { navPropKey = keyExp; break; } } ResourceContainer associatedContainer = container.FindDefaultRelatedContainer(p); if (navPropKey == null) { if (p.OtherAssociationEnd.ResourceType.Key.Properties.OfType<ResourceProperty>() .Where(rp => rp.ForeignKeys.Any()) .Any(rp => rp.ForeignKeys.First().PrimaryKey.Properties.OfType<ResourceProperty>().First().ResourceType.Equals(this))) { // this association has a fk back to the current type, so it cannot be based on any existing entity AstoriaTestLog.WriteLineIgnore("Skipping nav prop '{0}.{1}' due to foreign key constraint on entity being created", this.Name, p.Name); continue; } else navPropKey = associatedContainer.Workspace.GetRandomExistingKey(associatedContainer, p.OtherAssociationEnd.ResourceType); } if (navPropKey != null) { if (p.OtherAssociationEnd.Multiplicity == Multiplicity.Many) properties.Add(ResourceInstanceUtil.CreateCollectionInstanceProperty(new KeyExpressions(navPropKey), navPropKey.ResourceContainer, p)); else properties.Add(ResourceInstanceUtil.CreateRefInstanceProperty(navPropKey, navPropKey.ResourceContainer, p)); } } } return ResourceInstanceUtil.CreateKeyedResourceInstance(key.CreateKeyExpression(container, this), container, properties.ToArray()); }
public static KeyedResourceInstance CreateKeyedResourceInstance(KeyExpression exp, ResourceContainer container, params ResourceInstanceProperty[] properties) { ResourceType resType = exp.Properties.OfType<ResourceProperty>().First().ResourceType; ResourceInstanceKey instanceKey = ResourceInstanceKey.ConstructResourceInstanceKey(exp); return new KeyedResourceInstance(instanceKey, properties); }
public KeyedResourceInstance CreateRandomResource(ResourceContainer container, KeyExpression specifiedKey) { List<ResourceInstanceProperty> properties = new List<ResourceInstanceProperty>(); foreach (ResourceProperty p in this.Properties.OfType<ResourceProperty>().Where(rp => rp.IsNavigation == false && rp.PrimaryKey == null)) { ResourceInstanceProperty property = p.CreateRandomResourceInstanceProperty(); properties.Add(property); } return ResourceInstanceUtil.CreateKeyedResourceInstance(specifiedKey, container, properties.ToArray()); }
public static string ConstructRandomETag(ResourceContainer container) { ResourceType type = container.BaseType; Dictionary<string, object> randomProperties = new Dictionary<string, object>(); foreach (NodeProperty p in type.Properties.Where(p => p.Facets.ConcurrencyModeFixed)) randomProperties[p.Name] = (p as ResourceProperty).CreateRandomResourceSimpleInstanceProperty().PropertyValue; return ConstructETag(container, randomProperties); }
public static ResourceInstanceProperty CreateCollectionInstanceProperty(KeyExpressions keyExps, ResourceContainer container, ResourceProperty navProperty) { ResourceType navResourceType = (navProperty.Type as CollectionType).SubType as ResourceType; List<AssociationResourceInstance> associationNodes = new List<AssociationResourceInstance>(); foreach (KeyExpression associatedKey in keyExps) { ResourceInstanceKey resourceInstanceKey = ResourceInstanceKey.ConstructResourceInstanceKey(associatedKey); associationNodes.Add(new AssociationResourceInstance(resourceInstanceKey, AssociationOperation.Add)); } if (associationNodes.Count > 0) { ResourceInstanceNavColProperty navigationProperty = new ResourceInstanceNavColProperty(navProperty.Name, associationNodes.ToArray()); return navigationProperty; } return null; }
private static ResourceInstanceKey TryCreateUniqueResourceInstanceKey(ResourceContainer container, ResourceType resType, KeyExpressions relatedForeignKeys) { Workspace workspace = container.Workspace; List<ResourceInstanceSimpleProperty> keyProperties = new List<ResourceInstanceSimpleProperty>(); Dictionary<ResourceProperty, ResourceProperty> foreignKeyMap = resType.Key.Properties.OfType<ResourceProperty>() .Where(p => p.ForeignKeys.Any()) .ToDictionary(p => p, p => p.ForeignKeys.First().PrimaryKey.Properties.OfType<ResourceProperty>().First()); Dictionary<string, ResourceProperty> reverseForeignKeyMap = new Dictionary<string, ResourceProperty>(); foreach (KeyValuePair<ResourceProperty, ResourceProperty> pair in foreignKeyMap) reverseForeignKeyMap[pair.Value.Name] = pair.Key; Dictionary<ResourceProperty, object> propertyValues = new Dictionary<ResourceProperty, object>(); List<ResourceProperty> constrainedProperties = new List<ResourceProperty>(); foreach(ResourceProperty property in resType.Key.Properties.OfType<ResourceProperty>()) { if(foreignKeyMap.ContainsKey(property)) constrainedProperties.Add(property); else { NodeValue obj = (property.Type as PrimitiveType).CreateRandomValueForFacets(property.Facets); propertyValues[property] = obj.ClrValue; } } foreach (ResourceProperty currentProperty in constrainedProperties) { if (propertyValues.ContainsKey(currentProperty)) continue; ResourceProperty foreignProperty = foreignKeyMap[currentProperty]; ResourceContainer foreignContainer = container.FindDefaultRelatedContainer(foreignProperty.ResourceType); KeyExpression foreignKey = relatedForeignKeys.Where(k => k.ResourceContainer == foreignContainer).FirstOrDefault(); if (foreignKey == null) { KeyExpressions foreignKeys = workspace.GetAllExistingKeysOfType(foreignContainer, foreignProperty.ResourceType); while (foreignKey == null && foreignKeys.Any()) { foreignKey = foreignKeys.Choose(); // ensure that for every property in the key, it matches any local values for (int i = 0; i < foreignKey.Properties.Length; i++) { string keyPropertyName = foreignKey.Properties[i].Name; ResourceProperty localProperty; if (reverseForeignKeyMap.TryGetValue(keyPropertyName, out localProperty)) { object keyValue = foreignKey.Values[i].ClrValue; object localValue; if (propertyValues.TryGetValue(localProperty, out localValue)) { if (localValue != keyValue) { foreignKeys.Remove(foreignKey); foreignKey = null; break; } } } } } if (foreignKey == null) AstoriaTestLog.FailAndThrow("Could not find an appropriate foreign key"); relatedForeignKeys.Add(foreignKey); } for (int i = 0; i < foreignKey.Properties.Length; i++) { NodeProperty p = foreignKey.Properties[i]; if (p.Name == foreignProperty.Name) propertyValues[currentProperty] = foreignKey.Values[i].ClrValue; else if (p.ForeignKeys.Count() > 0) { string foreign = p.ForeignKeys.First().PrimaryKey.Properties.OfType<ResourceProperty>().First().Name; ResourceProperty localProperty; if (reverseForeignKeyMap.TryGetValue(foreign, out localProperty)) propertyValues[localProperty] = foreignKey.Values[i].ClrValue; } } } foreach(ResourceProperty property in resType.Key.Properties.OfType<ResourceProperty>()) if(!propertyValues.ContainsKey(property)) propertyValues[property] = (object)null; foreach (KeyValuePair<ResourceProperty, object> pair in propertyValues) { keyProperties.Add(new ResourceInstanceSimpleProperty(pair.Key.Facets, pair.Key.Name, pair.Value)); } ResourceInstanceKey resourceInstanceKey = new ResourceInstanceKey(container, resType, keyProperties.ToArray()); return resourceInstanceKey; }
public static ResourceInstanceProperty CreateRefInstanceProperty(KeyExpression keyExp, ResourceContainer container, ResourceProperty navProperty) { ResourceType navResourceType = navProperty.Type as ResourceType; ResourceInstanceKey resourceInstanceKey = ResourceInstanceKey.ConstructResourceInstanceKey(keyExp); return new ResourceInstanceNavRefProperty(navProperty.Name, new AssociationResourceInstance(resourceInstanceKey, AssociationOperation.Add)); }
internal static KeyedResourceInstance CreateKeyedResourceInstanceFromPayloadObject(ResourceContainer container, ResourceType resourceType, PayloadObject payloadObject) { List<ResourceInstanceProperty> properties = new List<ResourceInstanceProperty>(); List<ResourceInstanceProperty> keyProperties = new List<ResourceInstanceProperty>(); foreach (ResourceProperty property in resourceType.Properties.OfType<ResourceProperty>()) { if (property.IsNavigation) continue; if (property.IsComplexType) { PayloadComplexProperty fromPayload = payloadObject[property.Name] as PayloadComplexProperty; properties.Add(ConvertComplexPayloadObjectToComplexProperty(property, fromPayload)); } else { string stringValue; if (payloadObject.PayloadProperties.Any(p => p.Name == property.Name)) { PayloadSimpleProperty fromPayload = payloadObject[property.Name] as PayloadSimpleProperty; stringValue = fromPayload.Value; } else { if (!payloadObject.CustomEpmMappedProperties.TryGetValue(property.Name, out stringValue)) stringValue = null; } ResourceInstanceProperty newProperty = null; object val = CommonPayload.DeserializeStringToObject(stringValue, property.Type.ClrType, false, payloadObject.Format); newProperty = new ResourceInstanceSimpleProperty(property.Name, new NodeValue(val, property.Type)); if (property.PrimaryKey != null) keyProperties.Add(newProperty); else properties.Add(newProperty); } } ResourceInstanceKey key = new ResourceInstanceKey(container, resourceType, keyProperties.ToArray()); return new KeyedResourceInstance(key, properties.ToArray()); }
public static void ExecuteLinq(Workspace workspace, ExpNode q, ResourceContainer container, bool bSingle, ExpNode altq) { System.Uri uri = new Uri(workspace.ServiceUri); WebDataCtxWrapper ctx = new WebDataCtxWrapper(uri); ctx.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials; ctx.MergeOption = MergeOption.NoTracking; Type resType = container.BaseType.ClientClrType; ResolveClientType(workspace, ctx, resType); Type cType = typeof(WebDataCtxWrapper); MethodInfo mi = cType.GetMethod("CreateQuery", new Type[] { typeof(string) }); Type pType = container.BaseType.ClientClrType; MethodInfo miConstructed = mi.MakeGenericMethod(pType); string uri2 = container.Name; AstoriaTestLog.WriteLineIgnore(workspace.ServiceUri + "/" + uri2); object[] args = { uri2 }; object query = miConstructed.Invoke(ctx, args); LinqQueryBuilder lb = new LinqQueryBuilder(workspace, (IQueryable)query); string uri3 = lb.Build(q); AstoriaTestLog.WriteLineIgnore("Linq expression: " + lb.QueryExpression); //if (bSingle) //{ // var single = lb.QueryResultSingle; // VerifyLinqSingle(workspace, altq, single, container); //} //else //{ var queryable = lb.QueryResult; VerifyLinq(workspace, q, (IQueryable)queryable); //} }