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