//public virtual ResourceForUpload[] GetResourcesForUpload(Display display, // ResourceDescriptor[] resourceDescriptors, // out bool isEnoughFreeSpace) //{ // isEnoughFreeSpace = true; // return new ResourceForUpload[] { }; //} public virtual ResourceDescriptor[] GetResourcesForUpload(DisplayType displayType, ResourceDescriptor[] resourceDescriptors, out bool isEnoughFreeSpace) { isEnoughFreeSpace = true; return new ResourceDescriptor[] { }; }
public void TestResourceCachingToFileSystem() { // the resource handler expects the filenames to be retrieved in an array string[] resources = new[] { "simplified_enumlibrary.xmi", "simplified_primlibrary.xmi", "simplified_cdtlibrary.xmi" };// TODO: temporarily excluded since it caused a filure for whatever reason, "simplified_cclibrary.xmi" }; // the uri where the files to be downloaded are located const string downloadUri = "http://www.umm-dev.org/xmi/testresources/simplified_1/"; // the directory on the local file system where the downloaded file is to be stored string storageDirectory = Directory.GetCurrentDirectory() + "\\..\\..\\..\\VIENNAAddInUnitTests\\testresources\\ResourceHandlerTest\\xmi\\download\\"; string comparisonDirectory = Directory.GetCurrentDirectory() + "\\..\\..\\..\\VIENNAAddInUnitTests\\testresources\\ResourceHandlerTest\\xmi\\reference\\"; // method to be tested 1: caching resources locally ResourceDescriptor resourceDescriptor = new ResourceDescriptor ( resources, downloadUri, storageDirectory ); (new ResourceHandler(resourceDescriptor)).CacheResourcesLocally(); foreach (string fileName in resources) { // evaluate if the file was downloaded at all AssertDownloadedFileExists(storageDirectory + fileName); // evalate the content of the file downloaded AssertFileContent(comparisonDirectory + fileName, storageDirectory + fileName); } }
public void GetResourceCultureNameTest(string fileName, string expectedCulture) { var resourceDescriptor = new ResourceDescriptor(); resourceDescriptor.FileName = fileName; var culture = ResourcesForCulture.GetResourceCultureName(resourceDescriptor); Assert.Equal(expectedCulture, culture); }
public void Import(Presentation presentation, ResourceDescriptor[] resourceDescriptors, DeviceResourceDescriptor[] deviceResourceDescriptors, Func<Slide, Slide> addSlideDelegate, Func<IEnumerable<Slide>, bool> addLinkDelegate, Func<string, string, bool> isSlideUniqueName, int indent, int height) { _addSlideDelegate = addSlideDelegate; _addLinkDelegate = addLinkDelegate; _isSlideUniqueName = isSlideUniqueName; string selectedFile = null; using (OpenFileDialog openFileDialog = new OpenFileDialog()) { openFileDialog.RestoreDirectory = true; openFileDialog.Filter = "XML Files (*.xml) | *.xml"; openFileDialog.Multiselect = false; if (DialogResult.OK == openFileDialog.ShowDialog()) { selectedFile = openFileDialog.FileName; } } if (string.IsNullOrEmpty(selectedFile)) return; ImportSlide importSlide = new ImportSlide(DesignerClient.Instance.StandalonePresentationWorker, this); importSlide.Import(selectedFile, presentation, resourceDescriptors, deviceResourceDescriptors, indent, height); }
public void Import(string fileName, TechnicalServices.Persistence.SystemPersistence.Presentation.Presentation presentation, ResourceDescriptor[] resourceDescriptors, DeviceResourceDescriptor[] deviceResourceDescriptors, int indent, int height) { _indent = indent; _height = height; try { SlideBulk slideBulk = LoadFromFile(fileName, resourceDescriptors, deviceResourceDescriptors); if (slideBulk == null) { throw new InvalideFileException("Содержание файла некорректно. Импорт сцен невозмлжен"); } CheckSlideNames(slideBulk); AddSlideAndLink(presentation, slideBulk); _importSlideController.SuccessMessage("Импорт сцен успешно завершен"); } catch (InterruptOperationException) { } catch (InvalideFileException ex) { _importSlideController.ErrorMessage(ex.Message); } catch (Exception ex) { _importSlideController.ErrorMessage(string.Format("При экспорте сцен произошла неизвестная ошибка: {0}", ex)); } }
public static string GetResourceCultureName(ResourceDescriptor res) { var ext = Path.GetExtension(res.FileName); if (string.Equals(ext, ".resx", StringComparison.OrdinalIgnoreCase) || string.Equals(ext, ".restext", StringComparison.OrdinalIgnoreCase) || string.Equals(ext, ".resources", StringComparison.OrdinalIgnoreCase)) { var resourceBaseName = Path.GetFileNameWithoutExtension(res.FileName); var cultureName = Path.GetExtension(resourceBaseName); if (string.IsNullOrEmpty(cultureName) || cultureName.Length < 3) { return string.Empty; } // Path.Extension adds a . to the file extension name; example - ".resources". Removing the "." with Substring cultureName = cultureName.Substring(1); if (CultureInfoCache.KnownCultureNames.Contains(cultureName)) { return cultureName; } } return string.Empty; }
/// <summary> /// Creates a resource /// </summary> /// <param name="resourceDescriptor"></param> /// <param name="resource"></param> /// <returns></returns> public async Task <Resource> Create(ResourceDescriptor resourceDescriptor, Resource resource) { var resp = await HttpClient.PostAsync(resourceDescriptor.Url, new JsonContent(ResourceSerializer.Serialize(resource))); resp.EnsureSuccessStatusCode(); return(await ResourceSerializer.DeserializeResponseBodyToResource(resource.GetType(), resp)); }
public void SelectSource(ResourceDescriptor source, bool isLocal) { ISourceNode node = null; if (resourceNodes.TryGetValue(source, out node)) { _view.SelectSource(node, isLocal); } }
/// <summary> /// Gets a resource by its ID /// </summary> /// <param name="resourceDescriptor"></param> /// <returns></returns> public async Task <Resource> Get(ResourceDescriptor resourceDescriptor) { var resp = await HttpClient.GetAsync(resourceDescriptor.Url); resp.EnsureSuccessStatusCode(); return(await ResourceSerializer.DeserializeResponseBodyToResource(resourceDescriptor.Type, resp)); }
/// <summary> /// Gets a resource of type <see cref="T"/> by its ID /// </summary> /// <param name="resourceDescriptor"></param> /// <param name="resource"></param> /// <returns></returns> public virtual async Task <T> Update <T>(ResourceDescriptor resourceDescriptor, T resource) where T : Resource, new() { var resp = await HttpClient.PutAsync(resourceDescriptor.Url, new JsonContent(ResourceSerializer.Serialize(resource))); resp.EnsureSuccessStatusCode(); return(await ResourceSerializer.DeserializeResponseBodyToResource <T>(resp)); }
public void ShouldAppendRelativePathForMajorAndMinorVersionForLocalVersions() { ResourceDescriptor defaultDescriptor = new ResourceDescriptor(); ResourceDescriptor customDescriptor = new ResourceDescriptor("X:\\arbitrary\\path\\", "major", "minor"); Assert.That(customDescriptor.DownloadUri, Is.EqualTo("X:\\arbitrary\\path\\" + "major_minor\\")); Assert.That(customDescriptor.StorageDirectory, Is.EqualTo(defaultDescriptor.StorageDirectory + "major_minor\\")); }
public void ShouldAppendRelativePathForMajorAndMinorVersionForRemoteVersions() { ResourceDescriptor defaultDescriptor = new ResourceDescriptor(); ResourceDescriptor customDescriptor = new ResourceDescriptor("http://xmi/", "major", "minor"); Assert.That(customDescriptor.DownloadUri, Is.EqualTo("http://xmi/" + "major_minor/")); Assert.That(customDescriptor.StorageDirectory, Is.EqualTo(defaultDescriptor.StorageDirectory + "major_minor\\")); }
/// <summary> /// Gets a resource of type <see cref="T"/> by its ID /// </summary> /// <param name="resourceDescriptor"></param> /// <returns></returns> public async Task <T> Get <T>(ResourceDescriptor resourceDescriptor) where T : Resource, new() { var resp = await HttpClient.GetAsync(resourceDescriptor.Url); resp.EnsureSuccessStatusCode(); return(await ResourceSerializer.DeserializeResponseBodyToResource <T>(resp)); }
/// <summary> /// Queries resources of type <see cref="T"/> using the provided criteria, in the form of key/value pairs /// </summary> /// <param name="resourceDescriptor"></param> /// <returns></returns> public virtual async Task <IEnumerable <T> > Query <T>(ResourceDescriptor resourceDescriptor) where T : Resource, new() { var resp = await HttpClient.GetAsync(resourceDescriptor.Url); resp.EnsureSuccessStatusCode(); return(await ResourceSerializer.DeserializeResponseBodyToResourceCollection <T>(resp)); }
/// <summary> /// Initializes a new <see cref="ResourceDescriptor"/> instance. /// </summary> /// <param name="type">The type of resource to create the descriptor for.</param> /// <param name="offset">The offset in the resource from the start of the shader mapping.</param> /// <param name="descriptor">The resulting <see cref="ResourceDescriptor"/> instance.</param> public static void Create(int type, uint offset, out ResourceDescriptor descriptor) { descriptor.RangeType = (D3D12_DESCRIPTOR_RANGE_TYPE)type; descriptor.NumDescriptors = 1; descriptor.BaseShaderRegister = offset; descriptor.RegisterSpace = 0; descriptor.Flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE; descriptor.OffsetInDescriptorsFromTableStart = D3D12.D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND; }
public ResourceDescriptor[] GetResourcesForUpload(ResourceDescriptor[] resourceDescriptors, out bool isEnoughFreeSpace) { List<ResourceDescriptor> resourcesForUpload = new List<ResourceDescriptor>(resourceDescriptors.Length); foreach (ResourceDescriptor resourceDescriptor in resourceDescriptors) { ResourceFileInfo resourceFileInfo = resourceDescriptor.ResourceInfo as ResourceFileInfo; if (resourceFileInfo == null) continue; //List<ResourceFileProperty> resourceIdList = new List<ResourceFileProperty>(resourceFileInfo.ResourceFileDictionary.Count); foreach (ResourceFileProperty property in resourceFileInfo.ResourceFileList) { //string resourceFileName = GetRealResourceFileName(resourceDescriptor, pair.Key); if (!IsResourceExists(resourceDescriptor, property.Id) || IsNewly(resourceDescriptor, property.Id)) { //resourceIdList.Add(pair.Value); property.Newly = true; } } if (resourceFileInfo.ResourceFileList.Any(rfp => rfp.Newly)) resourcesForUpload.Add(resourceDescriptor); //if (resourceIdList.Count > 0) // resourcesForUpload.Add(new ResourceForUpload(resourceDescriptor, resourceIdList)); } long requiredSpaceForLocal = 0; long requiredSpaceForGlobal = 0; foreach (ResourceDescriptor descriptor in resourcesForUpload) { ResourceFileInfo resourceFileInfo = descriptor.ResourceInfo as ResourceFileInfo; if (resourceFileInfo == null) continue; if (descriptor.IsLocal) requiredSpaceForLocal += resourceFileInfo.ResourceFileList.Sum(rfp => rfp.Newly ? rfp.Length : 0); else requiredSpaceForGlobal += resourceFileInfo.ResourceFileList.Sum(rfp => rfp.Newly ? rfp.Length : 0); } //foreach (ResourceForUpload resourceForAgentUpload in resourcesForUpload) //{ // ResourceDescriptor descriptor = resourceForAgentUpload.ResourceDescriptor; // if (descriptor.IsLocal) // requiredSpaceForLocal += resourceForAgentUpload.ResourcePropertyList.Sum(rfp => rfp.Length); // else // requiredSpaceForGlobal += resourceForAgentUpload.ResourcePropertyList.Sum(rfp => rfp.Length); //} DriveInfo localDriveInfo = new DriveInfo( Path.GetFullPath(_configuration.LocalSourceFolder)[0].ToString()); DriveInfo globalDriveInfo = new DriveInfo( Path.GetFullPath(_configuration.GlobalSourceFolder)[0].ToString()); if (localDriveInfo.AvailableFreeSpace > requiredSpaceForLocal && globalDriveInfo.AvailableFreeSpace > requiredSpaceForGlobal) isEnoughFreeSpace = true; else isEnoughFreeSpace = false; return resourcesForUpload.ToArray(); }
/// <summary> /// Gets a resource of type <see cref="JobAssignment"/> by its ID /// </summary> /// <param name="resourceDescriptor"></param> /// <param name="resource"></param> /// <returns></returns> public override async Task <JobAssignment> Create(ResourceDescriptor resourceDescriptor, JobAssignment resource) { // create the job assinment in the data layer var jobAssignment = await base.Create(resourceDescriptor, resource); // invoke worker await WorkerFunctionInvoker.Invoke(Environment.WorkerFunctionName(), Environment, resource); // return the newly-created job assignment return(jobAssignment); }
/// <summary> /// Checks if a resource is local /// </summary> /// <param name="resourceDescriptor"></param> /// <returns></returns> private bool IsLocal(ResourceDescriptor resourceDescriptor) { var isLocal = !string.IsNullOrWhiteSpace(Environment.PublicUrl()) && resourceDescriptor.Url.StartsWith(Environment.PublicUrl()); Logger.Debug("Executing operation for {0} resource at {1} (local url = {2})", isLocal ? "local" : "remote", resourceDescriptor.Url, Environment.PublicUrl()); return(isLocal); }
private TypeBase CreateConstantResourceName(ResourceDescriptor descriptor, string nameValue) { if (descriptor.IsRootType) { return(factory.Create(() => new StringLiteralType { Value = nameValue })); } return(builtInTypes[BuiltInTypeKind.String]); }
protected override void onItemInserted(ResourceDescriptor descriptor) { // add onClick on resource handlers var button = descriptor.controller.button; Debug.Log("Creating onClick listener for an inventary resource: "); button.onClick.AddListener((() => { CraftMenuController controller = this.CraftMenuController; Debug.Log("Processing click for inventary resource via controller: ", controller); controller.moveResourceToCraft(descriptor); })); }
public void TryGetResourceDescriptor_Returns_False_If_Type_Is_IIdentifiable() { // Arrange Type resourceType = typeof(string); var typeLocator = new TypeLocator(); // Act ResourceDescriptor descriptor = typeLocator.TryGetResourceDescriptor(resourceType); // Assert Assert.Null(descriptor); }
/// <summary> /// Creates an implementation of <see cref="IResource"/> /// based on the descriptor. /// <seealso cref="ResourceManager"/> /// <seealso cref="ResourceFacade"/> /// </summary> /// <param name="descriptor"></param> /// <param name="appAssembly"></param> /// <returns></returns> public IResource Create(ResourceDescriptor descriptor, Assembly appAssembly) { var assembly = ResolveAssembly(descriptor.AssemblyName, appAssembly); var cultureInfo = ResolveCulture(descriptor.CultureName); if (logger.IsDebugEnabled) { logger.DebugFormat("Creating resource name {0}, assembly {1}, resource {2}", descriptor.Name, descriptor.AssemblyName, descriptor.ResourceName); } var manager = new ResourceManager(descriptor.ResourceName, assembly, descriptor.ResourceType); return new ResourceFacade(manager, cultureInfo); }
/// <summary> /// Handle update of a job /// </summary> /// <param name="resourceDescriptor"></param> /// <param name="resource"></param> public override async Task <JobProcess> Update(ResourceDescriptor resourceDescriptor, JobProcess resource) { var jobProcess = await DataHandler.Get <JobProcess>(resourceDescriptor); // validate the update if (jobProcess.JobProcessStatus == "New" && !new[] { "Running", "Completed", "Failed" }.Contains(resource.JobProcessStatus) || jobProcess.JobProcessStatus == "Running" && !new[] { "Completed", "Failed" }.Contains(resource.JobProcessStatus)) { throw new Exception($"Cannot change status of job process from '{jobProcess.JobProcessStatus}' to '{resource.JobProcessStatus}'"); } jobProcess.JobProcessStatus = resource.JobProcessStatus; var job = await DataHandler.Get <Job>(jobProcess.Job.Id); // update job job.JobStatus = jobProcess.JobProcessStatus; job.JobStatusReason = jobProcess.JobProcessStatusReason; // update output from job assignment if (!string.IsNullOrWhiteSpace(jobProcess.JobAssignment)) { var jobAssignment = await DataHandler.Get <JobAssignment>(jobProcess.JobAssignment); job.JobOutput = jobAssignment.JobOutput; } await DataHandler.Update(job); // clear the job assignment jobProcess.JobAssignment = null; var updated = await base.Update(resourceDescriptor, jobProcess); // send notification to async endpoint if provided if (job.AsyncEndpoint != null) { if (job.JobStatus == "Completed" && !string.IsNullOrWhiteSpace(job.AsyncEndpoint.AsyncSuccess)) { await DataHandler.Get(job.AsyncEndpoint.AsyncSuccess); } else if (job.JobStatus == "Failed" && !string.IsNullOrWhiteSpace(job.AsyncEndpoint.AsyncFailure)) { await DataHandler.Get(job.AsyncEndpoint.AsyncFailure); } } return(updated); }
protected void AddResource(string name, string resourceName, Assembly asm) { IResourceFactory resourceFactory = new DefaultResourceFactory(); var descriptor = new ResourceDescriptor( null, name, resourceName, null, null); var resource = resourceFactory.Create( descriptor, asm); ControllerContext.Resources.Add(name, resource); }
/// <summary> /// Creates an implementation of <see cref="IResource"/> /// based on the descriptor. /// <seealso cref="ResourceManager"/> /// <seealso cref="ResourceFacade"/> /// </summary> /// <param name="descriptor"></param> /// <param name="appAssembly"></param> /// <returns></returns> public IResource Create(ResourceDescriptor descriptor, Assembly appAssembly) { var assembly = ResolveAssembly(descriptor.AssemblyName, appAssembly); var cultureInfo = ResolveCulture(descriptor.CultureName); if (logger.IsDebugEnabled) { logger.DebugFormat("Creating resource name {0}, assembly {1}, resource {2}", descriptor.Name, descriptor.AssemblyName, descriptor.ResourceName); } var manager = new ResourceManager(descriptor.ResourceName, assembly, descriptor.ResourceType); return(new ResourceFacade(manager, cultureInfo)); }
/// <summary> /// Attempts to get a descriptor of the resource type. /// </summary> /// <returns> /// True if the type is a valid json:api type (must implement <see cref="IIdentifiable"/>), false otherwise. /// </returns> internal static bool TryGetResourceDescriptor(Type type, out ResourceDescriptor descriptor) { if (!type.IsAbstract) { var possible = GetIdType(type); if (possible.isJsonApiResource) { descriptor = new ResourceDescriptor(type, possible.idType); return(true); } } descriptor = ResourceDescriptor.Empty; return(false); }
public void TryGetResourceDescriptor_Returns_Type_If_Type_Is_IIdentifiable() { // Arrange Type resourceType = typeof(Model); var typeLocator = new TypeLocator(); // Act ResourceDescriptor descriptor = typeLocator.TryGetResourceDescriptor(resourceType); // Assert Assert.NotNull(descriptor); Assert.Equal(resourceType, descriptor.ResourceType); Assert.Equal(typeof(int), descriptor.IdType); }
/// <summary> /// Gets a resource of type <see cref="T"/> by its ID /// </summary> /// <param name="resourceDescriptor"></param> /// <param name="resource"></param> /// <returns></returns> public virtual async Task <T> Update(ResourceDescriptor resourceDescriptor, T resource) { // create any new child resources foreach (var childResource in resource.GetChildResources().Where(r => string.IsNullOrWhiteSpace(r.Id))) { await CreateResource(new ResourceDescriptor(resource.GetType()) { Parent = resourceDescriptor }, childResource); } // set the modified date to now resource.DateModified = DateTime.UtcNow; // call data layer to update the object resource = await DataHandler.Update(resourceDescriptor, resource); return(resource); }
protected override void onItemInserted(ResourceDescriptor descriptor) { // add onClick on resource handlers var button = descriptor.controller.button; Debug.Log("Creating onClick listener for an craft result resource: "); var type = descriptor.resource.GetType(); if (type == (typeof(Galaxy))) { button.onClick.AddListener((() => { // FIXME asem [REFACTOR] replace this code with calling api-method from InstantiatingApi script PauseMenuManager.CloseCraftMenu(); var result = Instantiate(prefab, new Vector3(5, 0, 0), Quaternion.identity) as GameObject; result.GetComponent <SpriteRenderer>().sortingOrder = 2; clear(); })); } else if (type == (typeof(Star))) { button.onClick.AddListener((() => { PauseMenuManager.CloseCraftMenu(); InstantiatingApi.CreateStar(); clear(); })); } else if (type == (typeof(Planet))) { button.onClick.AddListener((() => { PauseMenuManager.CloseCraftMenu(); InstantiatingApi.CreatePlanet(); clear(); })); } else { button.onClick.AddListener((() => { CraftMenuController controller = this.CraftMenuController; Debug.Log("Processing click for craft resource via controller: ", controller); controller.moveCraftResultToResources(descriptor); })); } }
void FreeResource(ResourceDescriptor desc) { if (!desc.autoAlloc) { return; } if (desc.allocatedTexture != null) { CoreUtils.Destroy(desc.allocatedTexture); } else if (desc.allocatedBuffer != null) { desc.allocatedBuffer.Release(); } desc.allocatedTexture = null; desc.allocatedBuffer = null; }
private static ResourceName CreateConstantResourceName(ResourceDescriptor descriptor, string nameValue, string description = null) { var constantNameSchema = descriptor.IsRootType ? JsonSchema.CreateSingleValuedEnum(nameValue) : new JsonSchema { JsonType = "string", Pattern = $"^.*/{Regex.Escape(nameValue)}$", }; constantNameSchema.Description = description; return(new ResourceName { HasConstantName = true, NameString = nameValue, NameSchema = constantNameSchema, }); }
/// <summary> /// Gets the path to a resource /// </summary> /// <param name="resourceDescriptor"></param> /// <returns></returns> public string GetUrlPath(ResourceDescriptor resourceDescriptor) { // start with the type var path = $"/{UrlSegmentResourceMapper.GetResourceTypeName(resourceDescriptor.Type)}"; // check if we have an ID if (resourceDescriptor.Id != null) { path += $"/{resourceDescriptor.Id}"; } // recurse up the tree for child collections if (resourceDescriptor.Parent != null) { path = GetUrlPath(resourceDescriptor.Parent) + path; } return(path); }
/// <summary> /// Overridden to send job to job processor /// </summary> /// <param name="resourceDescriptor"></param> /// <param name="resource"></param> /// <returns></returns> public override async Task<Job> Create(ResourceDescriptor resourceDescriptor, Job resource) { resource.JobStatus = "New"; // create the job var job = await base.Create(resourceDescriptor, resource); // get all services var services = await DataHandler.Query<Service>(ResourceDescriptor.FromUrl<Service>(Environment.ServiceRegistryServicesUrl())); // find first service that has a job processing endpoint var serviceResource = services .SelectMany(s => s.HasResource.Select(r => new {Service = s, Resource = r})) .FirstOrDefault( sr => sr.Resource.ResourceType == nameof(JobProcess) && !string.IsNullOrWhiteSpace(sr.Resource.HttpEndpoint)); if (serviceResource == null) { job.JobStatusReason = "No JobProcessor endpoints registered in the service registry."; job.JobStatus = "Failed"; return await Update(resourceDescriptor, job); } try { // gets the authorized url var url = AuthorizedUrlBuilder.GetAuthorizedUrl(serviceResource.Resource); // send the job to the job processing endpoint await DataHandler.Create(ResourceDescriptor.FromUrl<JobProcess>(url), new JobProcess {Job = job}); return await Get(resourceDescriptor); } catch (Exception ex) { job.JobStatusReason = $"Failed to send job to JobProcessor endpoint {serviceResource.Resource.HttpEndpoint}: {ex}"; job.JobStatus = "Failed"; return await Update(resourceDescriptor, job); } }
public bool DecrementResource(ResourceDescriptor descriptor) { var resourceAmount = descriptor.resource.GetResourceAmount(); if (resourceAmount > 1) { descriptor.resource.DecreaseAmount(1); descriptor.controller.resourceAmountText.text = descriptor.resource.GetResourceAmount().ToString(); return(true); } if (resourceAmount == 1) { // deleting resource _resources.Remove(descriptor); Destroy(descriptor.resourceObject); return(true); } return(false); }
private bool IsNewly(ResourceDescriptor resourceDescriptor, string resourceId) { ResourceFileInfo resourceFileInfo = resourceDescriptor.ResourceInfo as ResourceFileInfo; if (resourceFileInfo == null) return false; string resourceFileName = GetResourceInfoFullFileName(resourceDescriptor); if (!File.Exists(resourceFileName)) return true; ResourceInfo stored = resourceDescriptor.ResourceInfo.GetResourceInfo(resourceFileName, ExtraTypes); ResourceFileInfo storedResourceFileInfo = stored as ResourceFileInfo; if (storedResourceFileInfo == null) return false; ResourceFileProperty resourceFileProperty = storedResourceFileInfo.ResourceFileList.Find(rfp => rfp.Id.Equals(resourceId)); return resourceFileProperty == null ? true : resourceFileProperty.ModifiedUtc.CompareTo( resourceFileInfo.ResourceFileList.Find(rfp => rfp.Id.Equals(resourceId)).ModifiedUtc) < 0; //if (resourceFileProperty == null) // return true; //return resourceFileProperty.ModifiedUtc.CompareTo(resourceFileInfo.ResourceFileDictionary[resourceId].ModifiedUtc) < 0; }
/// <summary> /// должно вызываться после десериализации для инициализации ссылочных полей /// </summary> /// <returns>возвращается список оборудования которое отсутсвует в конфигурации и таким образом было исключено из сценария</returns> public string[] InitReference(ModuleConfiguration config, ResourceDescriptor[] descriptors, DeviceResourceDescriptor[] deviceResourceDescriptors) { foreach (KeyValuePair<int, SlideLinkList> pair in _linkDictionary) { foreach (Link link in pair.Value.LinkList) { link.NextSlide = SlideList.Find(sl => sl.Id == link.NextSlideId); if (link.NextSlide == null) throw new KeyNotFoundException("SlideBulk.InitReference: Нет такого слайда в коллекции"); } } // Initreference для каждого слайда List<string> deletedEquipment = new List<string>(); foreach (Slide sl in SlideList) { deletedEquipment.AddRange(sl.InitReference(config, descriptors, deviceResourceDescriptors, true)); } return deletedEquipment.Distinct().ToArray(); }
public void UpdateManagedResource(ResourceDescriptor desc) { if (desc.autoAlloc && desc.allocatedTexture == null && desc.allocatedBuffer == null) { AllocateResource(desc); } if (!desc.autoAlloc && (desc.allocatedTexture != null || desc.allocatedBuffer != null)) { FreeResource(desc); } // TODO: check allocated size vs settings and do patch stuff if (desc.allocatedTexture != null) { var t = desc.allocatedTexture; int expectedWidth = desc.textureAllocMode == TextureAllocMode.SameAsOutput ? rtSettings.GetWidth(graph) : (int)desc.textureAllocMode; int expectedHeight = desc.textureAllocMode == TextureAllocMode.SameAsOutput ? rtSettings.GetHeight(graph) : (int)desc.textureAllocMode; int expectedDepth = desc.textureAllocMode == TextureAllocMode.SameAsOutput ? rtSettings.GetDepth(graph) : (int)desc.textureAllocMode; if (t.width != expectedWidth || t.height != expectedHeight || t.volumeDepth != expectedDepth) { t.Release(); t.width = expectedWidth; t.height = expectedHeight; t.volumeDepth = expectedDepth; t.Create(); } } if (desc.allocatedBuffer != null) { var b = desc.allocatedBuffer; if (b.stride != desc.bufferStride || b.count != desc.bufferSize) { b.Release(); desc.allocatedBuffer = AllocComputeBuffer(desc.bufferSize, desc.bufferStride); } } }
void AllocateResource(ResourceDescriptor desc) { var t = desc.sType.type; if (t == typeof(ComputeBuffer)) { desc.allocatedBuffer = AllocComputeBuffer(desc.bufferSize, desc.bufferStride); } else if (typeof(Texture).IsAssignableFrom(t)) { int expectedWidth = desc.textureAllocMode == TextureAllocMode.SameAsOutput ? rtSettings.GetWidth(graph) : (int)desc.textureAllocMode; int expectedHeight = desc.textureAllocMode == TextureAllocMode.SameAsOutput ? rtSettings.GetHeight(graph) : (int)desc.textureAllocMode; int expectedDepth = desc.textureAllocMode == TextureAllocMode.SameAsOutput ? rtSettings.GetDepth(graph) : (int)desc.textureAllocMode; RenderTextureDescriptor descriptor = new RenderTextureDescriptor { // TODO: custom size width = expectedWidth, height = expectedHeight, volumeDepth = expectedDepth, autoGenerateMips = false, useMipMap = false, graphicsFormat = GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite = true, depthBufferBits = 0, dimension = TextureUtils.GetDimensionFromType(t), msaaSamples = 1, }; desc.allocatedTexture = new RenderTexture(descriptor) { name = "AutoAllocated - " + name, hideFlags = HideFlags.HideAndDontSave, }; desc.allocatedTexture.Create(); } }
public ResourceDescriptor CopySourceFromGlobalToLocal(ResourceDescriptor descriptor, string uniqueName) { return _presentationClient.Channel.CopySourceFromGlobalToLocal(UserIdentity, descriptor, uniqueName); }
protected void AddResource(string name, string resourceName, Assembly asm) { IResourceFactory resourceFactory = new DefaultResourceFactory(); ResourceDescriptor descriptor = new ResourceDescriptor( null, name, resourceName, null, null); IResource resource = resourceFactory.Create( descriptor, asm); ControllerContext.Resources.Add(name, resource); }
public SlideBulk LoadSlideBulk(string fileName, ResourceDescriptor[] resourceDescriptors, DeviceResourceDescriptor[] deviceResourceDescriptors) { throw new System.NotImplementedException(); }
public SavePresentationResult SavePresentationChanges(PresentationInfo presentationInfo, Slide[] slides, out ResourceDescriptor[] notExistedResources, out DeviceResourceDescriptor[] notExistedDeviceResources, out int[] labelNotExists, out UserIdentity[] whoLock, out int[] slidesAlreadyExistsId) { return _presentationClient.Channel.SavePresentationChanges(UserIdentity, presentationInfo, slides, out notExistedResources, out notExistedDeviceResources, out labelNotExists, out whoLock, out slidesAlreadyExistsId); }
public virtual ResourceDescriptor InitSourceDownload(UserIdentity identity, ResourceDescriptor resourceDescriptor) { throw new System.NotImplementedException(); }
public virtual FileSaveStatus SaveSource(UserIdentity userIdentity, ResourceDescriptor resourceDescriptor, SourceStatus status, out string newResourceId) { throw new System.NotImplementedException(); }
public bool IsResourceAvailable(ResourceDescriptor descriptor) { return _presentationClient.Channel.IsResourceAvailable(descriptor); }
public ResourceDescriptor CopySourceFromLocalToGlobal(UserIdentity sender, ResourceDescriptor resourceDescriptor) { return _sourceDAL.CopySourceFromLocalToGlobal(sender, resourceDescriptor); }
public ResourceDescriptor CopySourceFromGlobalToLocal(UserIdentity sender, ResourceDescriptor resourceDescriptor, string presentationUniqueName) { return _sourceDAL.CopySourceFromGlobalToLocal(sender, resourceDescriptor, presentationUniqueName); }
public bool IsResourceAvailable(ResourceDescriptor descriptor) { return _sourceDAL.IsResourceAvailable(descriptor); }
public FileSaveStatus GetSourceStatus(ResourceDescriptor descriptor) { return _sourceDAL.GetSourceStatus(descriptor); }
public ResourceDescriptor CopySourceFromLocalToGlobal(ResourceDescriptor descriptor) { return _presentationClient.Channel.CopySourceFromLocalToGlobal(UserIdentity, descriptor); }
private SlideBulk LoadFromFile(string fileName, ResourceDescriptor[] resourceDescriptors, DeviceResourceDescriptor[] deviceResourceDescriptors) { return _standalonePresentationWorker.LoadSlideBulk(fileName, resourceDescriptors, deviceResourceDescriptors); }
public void RemoveManagedResource(ResourceDescriptor desc) { FreeResource(desc); managedResources.Remove(desc); }
public PresentationInfo[] GetPresentationWhichContainsSource(ResourceDescriptor resourceDescriptor) { return _presentationDAL.GetPresentationWhichContainsSource(resourceDescriptor); }
public SavePresentationResult SavePresentationChanges(UserIdentity userIdentity, PresentationInfo presentationInfo, Slide[] newSlideArr, out ResourceDescriptor[] resourcesNotExists, out DeviceResourceDescriptor[] deviceResourcesNotExists, out int[] labelNotExists, out UserIdentity[] whoLock, out int[] slidesAlreadyExistsId) { resourcesNotExists = new ResourceDescriptor[] { }; deviceResourcesNotExists = new DeviceResourceDescriptor[] {}; whoLock = new UserIdentity[] { }; slidesAlreadyExistsId = new int[] { }; labelNotExists = presentationInfo.GetUsedLabels().Except( _configuration.LabelStorageAdapter.GetLabelStorage().Select(lb => lb.Id)).ToArray(); if (labelNotExists.Length != 0) return SavePresentationResult.LabelNotExists; if (!IsStandAlone) { // необходим лок уровня презентации LockingInfo info = _lockService.GetLockInfo(ObjectKeyCreator.CreatePresentationKey(presentationInfo)); if (info == null || !info.UserIdentity.Equals(userIdentity)) return SavePresentationResult.PresentationNotLocked; } string[] deletedEquipment; Presentation presentationStored = _presentationDAL.GetPresentation( presentationInfo.UniqueName, _sourceDAL, _deviceSourceDAL, out deletedEquipment); if (presentationStored == null) return SavePresentationResult.PresentationNotExists; resourcesNotExists = GetNotExistedResource(newSlideArr); deviceResourcesNotExists = GetNotExistedDeviceResource(newSlideArr, presentationInfo); if (resourcesNotExists.Length != 0 || deviceResourcesNotExists.Length != 0) return SavePresentationResult.ResourceNotExists; LockingInfo[] lockedSlides; Slide[] slideAlreadyExists; presentationStored = Merge(userIdentity, presentationInfo, newSlideArr, presentationStored, out lockedSlides, out slideAlreadyExists); if (presentationStored == null) { SavePresentationResult result = SavePresentationResult.Unknown; if (lockedSlides.Length != 0) { whoLock = lockedSlides.Select(li => li.UserIdentity).ToArray(); result = SavePresentationResult.SlideLocked; } if (slideAlreadyExists.Length != 0) { slidesAlreadyExistsId = slideAlreadyExists.Select(sl => sl.Id).ToArray(); result = SavePresentationResult.SlideAlreadyExists; } return result; } bool isSuccess = _presentationDAL.SavePresentation(userIdentity, presentationStored); if (isSuccess) { PresentationKey presentationKey = ObjectKeyCreator.CreatePresentationKey(presentationStored); ObjectChanged(userIdentity, new List<ObjectInfo> { new ObjectInfo(userIdentity, presentationKey) }, new PresentationInfo(presentationStored), true); } else { return SavePresentationResult.Unknown; } return SavePresentationResult.Ok; }
public bool SaveSlideChanges(string uniqueName, Slide[] slides, out int[] notLockedSlide, out ResourceDescriptor[] notExistedResources, out DeviceResourceDescriptor[] notExistedDeviceResources, out int[] labelNotExists) { return _presentationClient.Channel.SaveSlideChanges(UserIdentity, uniqueName, slides, out notLockedSlide, out notExistedResources, out notExistedDeviceResources, out labelNotExists); }
public bool SaveSlideChanges(UserIdentity userIdentity, string presentationUniqueName, Slide[] slideToSave, out int[] slideIdNotLocked, out ResourceDescriptor[] resourcesNotExists, out DeviceResourceDescriptor[] deviceResourcesNotExists, out int[] labelNotExists) { resourcesNotExists = new ResourceDescriptor[] { }; deviceResourcesNotExists = new DeviceResourceDescriptor[] {}; labelNotExists = slideToSave.Select(sl => sl.LabelId).Where(id=>id>0).Distinct().Except( _configuration.LabelStorageAdapter.GetLabelStorage().Select(lb => lb.Id)).ToArray(); List<int> slideNotLocked = new List<int>(slideToSave.Length); slideIdNotLocked = slideNotLocked.ToArray(); if (labelNotExists.Length != 0) return false; if (slideToSave.Length == 0) return true; if (!IsStandAlone) { //Presentation pres = BinarySerializer.Deserialize<Presentation>(presentation); // проверка что слайды залочены данным пользователем foreach (Slide slide in slideToSave) { LockingInfo info = _lockService.GetLockInfo(ObjectKeyCreator.CreateSlideKey(presentationUniqueName, slide.Id)); if (info == null || !info.UserIdentity.Equals(userIdentity)) slideNotLocked.Add(slide.Id); } } slideIdNotLocked = slideNotLocked.ToArray(); string[] deletedEquipment; Presentation presentation = _presentationDAL.GetPresentation(presentationUniqueName, _sourceDAL, _deviceSourceDAL, out deletedEquipment); if (presentation == null) return false; PresentationInfo presentationInfo = new PresentationInfo(presentation); resourcesNotExists = GetNotExistedResource(slideToSave); deviceResourcesNotExists = GetNotExistedDeviceResource(slideToSave, presentationInfo); if (slideIdNotLocked.Length != 0 || resourcesNotExists.Length != 0 || deviceResourcesNotExists.Length != 0) return false; presentation = Merge(presentation, slideToSave); if (presentation == null) return false; bool isSuccess = _presentationDAL.SavePresentation(userIdentity, presentation); if (isSuccess) { List<ObjectInfo> objectInfoList = new List<ObjectInfo>(); foreach (Slide slide in slideToSave) { objectInfoList.Add(new ObjectInfo(userIdentity, ObjectKeyCreator.CreateSlideKey(presentationUniqueName, slide.Id))); } PresentationKey presentationKey = ObjectKeyCreator.CreatePresentationKey(presentationUniqueName); ObjectChanged(userIdentity, objectInfoList, new PresentationInfo(presentation), false); } return isSuccess; }
public RemoveResult DeleteSource(UserIdentity sender, ResourceDescriptor descriptor) { PresentationInfo[] presentationInfos = _presentationDAL.GetPresentationWhichContainsSource(descriptor); if (presentationInfos != null && presentationInfos.Length != 0) return RemoveResult.LinkedToPresentation; return _sourceDAL.DeleteSource(sender, descriptor) ? RemoveResult.Ok : RemoveResult.NotExists; }
public SourceWindow(ResourceDescriptor info) : this(info.ResourceInfo.Name) { Mapping = info; }
public RemoveResult DeleteSource(ResourceDescriptor descriptor) { return _presentationClient.Channel.DeleteSource(UserIdentity, descriptor); }