public static void MapClrAttributesToDomResource(this IResourceType resourceType, DomReadWriteResource domResource, object clrResource, Func <string, string, bool> attributePredicate) { Contract.Requires(resourceType != null); Contract.Requires(domResource != null); if (clrResource == null) { return; } var serviceModel = domResource.GetServiceModel(); var domAttributes = domResource.CreateAndAddNode(() => DomAttributes.Create()); var apiType = resourceType.ResourceIdentityInfo.ApiType; var attributeInfoCollection = resourceType.AttributesInfo.Collection; foreach (var attributeInfo in attributeInfoCollection) { var apiField = attributeInfo.ApiPropertyName; if (attributePredicate != null && attributePredicate(apiType, apiField) == false) { // Skip adding this attribute. continue; } var localAttributeInfo = attributeInfo; domAttributes.CreateAndAddNode(() => DomAttribute.CreateFromClrResource(serviceModel, localAttributeInfo, clrResource)); } }
public bool TryGetResourceType(Type clrResourceType, out IResourceType resourceType) { resourceType = null; return(clrResourceType != null && this.ClrTypeToResourceTypeDictionary != null && this.ClrTypeToResourceTypeDictionary.TryGetValue(clrResourceType, out resourceType)); }
private static IResourceType LoadResourceField(System.Xml.XmlNode fieldNode) { IResourceType field = null; switch (fieldNode.Name) { case "text": field = new TextFieldType(); break; case "internal_ref": field = new InternalRefFieldType(); break; case "external_ref": field = new ExternalRefFieldType(); break; case "numeric": field = new NumericFieldType(); break; case "enum": field = new EnumFieldType(); break; } if (field != null) { field.LoadFromXML(fieldNode); } return(field); }
private static Link CreateResourceRelationshipLink(IHypermediaContext hypermediaContext, IResourcePathContext resourcePathContext, IResourceType resourceType, object clrResource, bool addRelationshipsPathSegment, IRelationshipInfo relationship, Meta apiRelationshipLinkMeta) { Contract.Requires(hypermediaContext != null); Contract.Requires(resourcePathContext != null); Contract.Requires(resourceType != null); Contract.Requires(clrResource != null); Contract.Requires(relationship != null); var clrResourceType = resourceType.ClrType; var urlBuilderConfiguration = hypermediaContext.GetUrlBuilderConfiguration(clrResourceType); var apiId = resourceType.GetApiId(clrResource); var apiResourcePath = resourcePathContext.GetResourceSelfPath(apiId); var apiRelationshipRelPathSegment = relationship.ApiRelPathSegment; var apiRelationshipLinkHRef = UrlBuilder.Create(urlBuilderConfiguration) .Path(apiResourcePath) .Path(Keywords.Relationships, addRelationshipsPathSegment) .Path(apiRelationshipRelPathSegment) .Build(); var apiRelationshipLink = new Link { HRef = apiRelationshipLinkHRef, Meta = apiRelationshipLinkMeta }; return(apiRelationshipLink); }
private void OnCLEMInitialiseActivity(object sender, EventArgs e) { // get bank account object to use bankAccount = Resources.FindResourceType <Finance, FinanceType>(this, AccountName, OnMissingResourceActionTypes.ReportWarning, OnMissingResourceActionTypes.ReportErrorAndStop); // get resource type to sell resourceToSell = Resources.FindResourceType <ResourceBaseWithTransactions, IResourceType>(this, ResourceTypeName, OnMissingResourceActionTypes.ReportErrorAndStop, OnMissingResourceActionTypes.ReportErrorAndStop); // find market if present Market market = Resources.FoundMarket; // find a suitable store to place resource if (market != null) { resourceToPlace = market.Resources.LinkToMarketResourceType(resourceToSell as CLEMResourceTypeBase) as IResourceType; } if (resourceToPlace != null) { price = resourceToPlace.Price(PurchaseOrSalePricingStyleType.Purchase); } if (price is null && resourceToSell.Price(PurchaseOrSalePricingStyleType.Sale) != null) { price = resourceToSell.Price(PurchaseOrSalePricingStyleType.Sale); } }
public bool TryGetResourceType(string apiResourceType, out IResourceType resourceType) { resourceType = null; return(String.IsNullOrWhiteSpace(apiResourceType) == false && this.ApiTypeToResourceTypeDictionary != null && this.ApiTypeToResourceTypeDictionary.TryGetValue(apiResourceType, out resourceType)); }
/// <summary> /// Loads from XML, the common properties which all resource types share /// </summary> /// <param name="resourceType">Type of the resource.</param> public static void LoadFromXML(XmlNode node, IResourceType resourceType) { if (node.Attributes["name"] == null) { throw new System.Xml.XmlException("The resource_type node does not contain a 'name' attribute at " + node.BaseURI); } resourceType.Name = node.Attributes["name"].Value; if (node.Attributes["help"] != null) { resourceType.Help = node.Attributes["help"].Value; } else { resourceType.Help = string.Empty; } if (node.Attributes["display_name"] != null) { resourceType.DisplayName = node.Attributes["display_name"].Value; } else { resourceType.DisplayName = resourceType.Name; } }
public static bool TryGetHomeResourceType(this IServiceModel serviceModel, out IResourceType homeResourceType) { Contract.Requires(serviceModel != null); homeResourceType = serviceModel.HomeResourceType; return(homeResourceType != null); }
public void Exec(IResource res, IActionParameterStore actionStore) { IResourceList categories = actionStore.ParametersAsResList(); IResourceList authors = res.GetLinksOfType(null, Core.ContactManager.Props.LinkFrom); foreach (IResource author in authors) { IResourceType type = Core.ResourceStore.ResourceTypes[author.TypeId]; // Do not assign categories for resource types which are // internal in the sence - they are not showable in the // traditional ResourceListView pane. Thus, user can not // benefit from setting a category to these internal types. if (!type.HasFlag(ResourceTypeFlags.Internal)) { ResourceProxy proxy = new ResourceProxy(author); proxy.BeginUpdate(); foreach (IResource category in categories) { proxy.AddLink("Category", category); } proxy.EndUpdate(); } } }
// PUBLIC METHODS /////////////////////////////////////////////////// #region Extensions Methods public static void MapClrTypeToDomResource(this IResourceType resourceType, DomReadWriteResource domResource) { Contract.Requires(resourceType != null); Contract.Requires(domResource != null); domResource.CreateAndAddNode(() => DomType.CreateFromResourceType(resourceType)); }
/// <summary> /// Removes the given item from the collection /// </summary> /// <returns>True, if the item was removed, otherwise False</returns> /// <param name="item">The item that should be removed</param> public override bool Remove(IModelElement item) { IResourceInterface resourceInterfaceItem = item.As <IResourceInterface>(); if (((resourceInterfaceItem != null) && this._parent.ResourceInterfaces__ResourceRepository.Remove(resourceInterfaceItem))) { return(true); } ISchedulingPolicy schedulingPolicyItem = item.As <ISchedulingPolicy>(); if (((schedulingPolicyItem != null) && this._parent.SchedulingPolicies__ResourceRepository.Remove(schedulingPolicyItem))) { return(true); } IResourceType resourceTypeItem = item.As <IResourceType>(); if (((resourceTypeItem != null) && this._parent.AvailableResourceTypes_ResourceRepository.Remove(resourceTypeItem))) { return(true); } return(false); }
public static void MapDomResourceToClrAttributes(this IResourceType resourceType, object clrResource, DomReadWriteResource domResource) { Contract.Requires(resourceType != null); Contract.Requires(clrResource != null); Contract.Requires(domResource != null); var domAttributesNode = domResource.GetNode <DomNodeType, DomAttributes>(DomNodeType.Attributes); if (domAttributesNode == null) { return; } var domAttributeNodes = domAttributesNode.Nodes() .Cast <DomAttribute>() .ToList(); foreach (var domAttributeNode in domAttributeNodes) { var clrPropertyName = domAttributeNode.ClrPropertyName; var clrPropertyValue = domAttributeNode.ClrAttribute; var clrAttribute = resourceType.GetClrAttributeInfo(clrPropertyName); clrAttribute.SetClrProperty(clrResource, clrPropertyValue); } }
private IResourcePathContextBuilder <TParentBuilder> AddPath(IResourceType resourceType, Type clrResourceType, string apiId, string rel) { Contract.Requires(resourceType != null); Contract.Requires(clrResourceType != null); Contract.Requires(String.IsNullOrWhiteSpace(apiId) == false); Contract.Requires(String.IsNullOrWhiteSpace(rel) == false); this.EnsureBasePathsExist(); var nextRelationship = resourceType.GetRelationshipInfo(rel); var nextRelationshipCanonicalRelPathMode = nextRelationship.ToCanonicalRelPathMode; if (nextRelationshipCanonicalRelPathMode == RelationshipCanonicalRelPathMode.DropPreviousPathSegments) { _resourceCanonicalBasePath.Clear(); _resourceCanonicalPathMode = default(ResourcePathMode); _resourceCanonicalPreviousRelationship = null; } else { AddPath(resourceType, clrResourceType, apiId, nextRelationship, ref _resourceCanonicalBasePath, ref _resourceCanonicalPathMode, ref _resourceCanonicalPreviousRelationship); } AddPath(resourceType, clrResourceType, apiId, nextRelationship, ref _resourceSelfBasePath, ref _resourceSelfPathMode, ref _resourceSelfPreviousRelationship); return(this); }
// For a resource to be text-indexed its resource type must conform // to the following criteria: // - have valid name // - be indexable // - its oqner plugin must be loaded // - even if its plugin is loaded (or the owner may be omitted), it // must be either a file (for a FilePlugin to be able to index it) or // have some ITextIndexProvider, specific for this particular // resource type. private static bool IsResTypeIndexingConformant(IResourceType resType) { return(!String.IsNullOrEmpty(resType.Name) && !resType.HasFlag(ResourceTypeFlags.NoIndex) && resType.OwnerPluginLoaded && (resType.HasFlag(ResourceTypeFlags.FileFormat) || Core.PluginLoader.HasTypedTextProvider(resType.Name))); }
/// <summary> /// 得到源文件的大小,通过 FileInfo对象获取 /// </summary> /// <param name="serverFileName">文件名</param> /// <param name="serverFolderName">文件夹名</param> /// <param name="fileType">根据fileType得到是属于什么类型的资源</param> /// <param name="previewType"></param> /// <returns></returns> public static long GetResourceFileSize(string serverFileName, string serverFolderName, string fileType, string previewType) { long l = 0; string resourceRootPath = string.Empty; string filePath = string.Empty; IResourceType obj = ResourceTypeFactory.getResourceType(fileType); //yangguang //filePath = Path.Combine(obj.SourcePath, serverFolderName); //filePath = Path.Combine(filePath, serverFileName); filePath = obj.GetSourcePath(serverFolderName, serverFileName); if (File.Exists(filePath)) { try { l = new FileInfo(filePath).Length; } catch (Exception ep) { LogWriter.WriteExceptionLog(ep, true); } } return(l); }
public void Init(Member member, IResourceType resource) { _member = member; _resourceType = resource; icon.sprite = resource.Icon; counter.text = $"{resource.StartingAmount}/{resource.MaxAmount}"; }
private void OnCLEMInitialiseActivity(object sender, EventArgs e) { // get bank account object to use bankAccount = Resources.GetResourceItem(this, AccountName, OnMissingResourceActionTypes.ReportWarning, OnMissingResourceActionTypes.ReportErrorAndStop) as FinanceType; // get resource type to sell resourceToSell = Resources.GetResourceItem(this, ResourceTypeName, OnMissingResourceActionTypes.ReportErrorAndStop, OnMissingResourceActionTypes.ReportErrorAndStop) as IResourceType; }
// PUBLIC METHODS /////////////////////////////////////////////////// #region IInfoObject Implementation public virtual void Initialize(IServiceModel serviceModel, IResourceType resourceType) { Contract.Requires(serviceModel != null); Contract.Requires(resourceType != null); this.ServiceModel = serviceModel; this.ResourceType = resourceType; }
private ResourceTypeStats With(IResourceType newResource, Func <int, int, int> combineOperation) { var key = newResource.Name; _resources[key] = _resources.TryGetValue(key, out var existing) ? new CombinedResourceTypeStats(existing, newResource, combineOperation) : newResource; return(this); }
protected bool Deactivate(IResourceType entity) { // Deactivate it ResourceTypesRepository.Deactivate(entity); // Try to Save Changes ResourceTypesRepository.SaveChanges(); // Finished! return(true); }
// PUBLIC METHODS /////////////////////////////////////////////////// #region IToOneResourceLinkage Implementation public ResourceIdentifier CreateApiResourceIdentifier(IResourceType resourceType) { Contract.Requires(resourceType != null); var clrResourceId = this.Value; var apiResourceIdentifier = resourceType.CreateApiResourceIdentifier(clrResourceId); return(apiResourceIdentifier); }
public virtual bool AreEqual(IResourceTypeModel model, IResourceType entity) { return(NameableEntityMapper.AreEqual(model, entity) // ResourceType Properties && model.DetailResourceName == entity.DetailResourceName && model.ListResourceName == entity.ListResourceName // Related Objects // <None> ); }
public static void MapApiLinksToClrResource(this IResourceType resourceType, object clrResource, IGetLinks apiGetLinks) { Contract.Requires(resourceType != null); Contract.Requires(clrResource != null); Contract.Requires(apiGetLinks != null); var apiLinks = apiGetLinks.Links; resourceType.SetClrLinks(clrResource, apiLinks); }
public virtual bool AreEqual(IResourceTypeModel model, IResourceType entity) { return NameableEntityMapper.AreEqual(model, entity) // ResourceType Properties && model.DetailResourceName == entity.DetailResourceName && model.ListResourceName == entity.ListResourceName // Related Objects // <None> ; }
// PUBLIC METHODS /////////////////////////////////////////////////// #region Extensions Methods public static void MapApiMetaToClrResource(this IResourceType resourceType, object clrResource, IGetMeta apiGetMeta) { Contract.Requires(resourceType != null); Contract.Requires(clrResource != null); Contract.Requires(apiGetMeta != null); var apiMeta = apiGetMeta.Meta; resourceType.SetClrMeta(clrResource, apiMeta); }
public static void MapApiRelationshipsToClrResource(this IResourceType resourceType, object clrResource, IGetRelationships apiGetRelationships) { Contract.Requires(resourceType != null); Contract.Requires(clrResource != null); Contract.Requires(apiGetRelationships != null); var apiRelationships = apiGetRelationships.Relationships; resourceType.SetClrRelationships(clrResource, apiRelationships); }
// PUBLIC METHODS /////////////////////////////////////////////////// #region Factory Methods public static DomType CreateFromResourceType(IResourceType resourceType) { Contract.Requires(resourceType != null); var apiResourceType = resourceType.ResourceIdentityInfo.ApiType; var clrResourceType = resourceType.ClrType; var domType = new DomType(apiResourceType, clrResourceType); return(domType); }
public CombinedResourceTypeStats(IResourceType first, IResourceType second, Func <int, int, int> operation) { if (!first.Name.Equals(second.Name)) { throw new ArgumentException("Cannot add {first.Name} to a {second.Name} modifier"); } _first = first; _second = second; _operation = operation; }
public static void CreateResourceTypeFields(IDictionary <string, IResourceType> container, XmlNode fieldParentNode) { foreach (System.Xml.XmlNode node in fieldParentNode.ChildNodes) { IResourceType fieldType = LoadResourceField(node); if (fieldType != null) { container.Add(fieldType.Name, fieldType); } } }
public static void MapApiIdToClrResource(this IResourceType resourceType, object clrResource, IGetResourceIdentity apiGetResourceIdentity) { Contract.Requires(resourceType != null); Contract.Requires(clrResource != null); Contract.Requires(apiGetResourceIdentity != null); var apiId = apiGetResourceIdentity.Id; var clrId = resourceType.ToClrId(apiId); resourceType.SetClrId(clrResource, clrId); }
public void SetToolTip(ToolTip provider) { foreach (RadioButton radioButton in _radioButtons.Values) { IResourceType type = _value.SubValues[radioButton.Name].MyType; provider.SetToolTip(radioButton, type.Help); } /// TODO: should the resource panel also use our tooltip /// or is it ok that it has its own tooltip? }
public virtual IResourceTypeModel MapToModelListing(IResourceType entity, int currentDepth = 1) { currentDepth++; var model = NameableEntityMapper.MapToModelListing<IResourceType, ResourceTypeModel>(entity); // ResourceType Properties model.DetailResourceName = entity.DetailResourceName; model.ListResourceName = entity.ListResourceName; // Related Objects // <None> // Return Entity return model; }
public virtual void MapToEntity(IResourceTypeModel model, ref IResourceType entity, int currentDepth = 1) { currentDepth++; // Assign Base properties NameableEntityMapper.MapToEntity(model, ref entity); // ResourceType Properties entity.DetailResourceName = model.DetailResourceName; entity.ListResourceName = model.ListResourceName; // Related Objects // <None> // Associated Objects entity.Promos = model.Promos?.Where(i => i.Active).Select(PromoMapperExtensions.MapToEntity).ToList(); }
public virtual IResourceTypeModel MapToModel(IResourceType entity, int currentDepth = 1) { currentDepth++; var model = NameableEntityMapper.MapToModel<IResourceType, ResourceTypeModel>(entity); // ResourceType Properties model.DetailResourceName = entity.DetailResourceName; model.ListResourceName = entity.ListResourceName; // Related Objects // <None> // Associated Objects model.Promos = entity.Promos?.Where(i => i.Active).Select(PromoMapperExtensions.MapToModelLite).ToList(); // Return Entity return model; }
/// <summary> /// Loads from XML, the common properties which all resource types share /// </summary> /// <param name="resourceType">Type of the resource.</param> public static void LoadFromXML(XmlNode node, IResourceType resourceType) { if (node.Attributes["name"] == null) throw new System.Xml.XmlException("The resource_type node does not contain a 'name' attribute at " + node.BaseURI); resourceType.Name = node.Attributes["name"].Value; if (node.Attributes["help"] != null) resourceType.Help = node.Attributes["help"].Value; else { resourceType.Help = string.Empty; } if (node.Attributes["display_name"] != null) resourceType.DisplayName = node.Attributes["display_name"].Value; else resourceType.DisplayName = resourceType.Name; }
public void Add(IResourceType entity) { Context.ResourceTypes.Add((ResourceType)entity); }
public static void MapToEntity(this IResourceTypeModel model, ref IResourceType entity, int currentDepth = 1) { Mapper.MapToEntity(model, ref entity, currentDepth); }
public void Remove(IResourceType entity) { Context.ResourceTypes.Remove((ResourceType)entity); }
public void Update(IResourceType entity) { Context.SetModified(entity); }
public static bool AreEqual(this IResourceTypeModel model, IResourceType entity) { return Mapper.AreEqual(model, entity); }
protected bool Deactivate(IResourceType entity) { // Deactivate it ResourceTypesRepository.Deactivate(entity); // Try to Save Changes ResourceTypesRepository.SaveChanges(); // Finished! return true; }
protected bool Remove(IResourceType entity) { if (entity == null) { return true; } // No entity found to remove, consider it passed // Remove it ResourceTypesRepository.Remove(entity); // Try to Save Changes ResourceTypesRepository.SaveChanges(); // Finished! return true; }
public void Deactivate(IResourceType entity) { entity.Active = false; Update(entity); }