/// <summary>
/// Loads all the dependent collection set for the given resource
/// </summary>
/// <param name="resource"> an resource object</param>
/// <returns> loaded resource </returns>
private static Core.Resource LoadResource(Core.Resource resource)
{
if (null == resource)
{
return(null);
}
ScholarlyWorks.ScholarlyWork scholarlyWork = resource as ScholarlyWorks.ScholarlyWork;
if (null != scholarlyWork)
{
if (!scholarlyWork.Authors.IsLoaded)
{
scholarlyWork.Authors.Load();
}
if (!scholarlyWork.Contributors.IsLoaded)
{
scholarlyWork.Contributors.Load();
}
if (!scholarlyWork.Tags.IsLoaded)
{
scholarlyWork.Tags.Load();
}
}
return(resource);
}
/// <summary>
/// Gets the type of the resource.
/// </summary>
/// <param name="resource">The resource.</param>
/// <returns>The <see cref="ResourceType"/>.</returns>
internal ResourceType GetResourceType(Core.Resource resource)
{
if (null == resource)
{
return(null);
}
return(GetResourceType(resource.GetType().FullName));
}
/// <summary>
/// retrieves resource object specific to resource id
/// </summary>
/// <param name="resourceId">id for retrieving specific object</param>
/// <returns>resource object</returns>
internal Core.Resource GetResource(Guid resourceId)
{
Core.Resource coreResource = null;
using (Core.ZentityContext zentityContext = CoreHelper.CreateZentityContext())
{
var returnedResource = zentityContext.Resources
.Where(resource => resource.Id == resourceId)
.FirstOrDefault();
if (returnedResource != null &&
returnedResource.Authorize("Read", zentityContext, GetAuthenticationToken()))
{
coreResource = LoadResource(returnedResource);
}
}
return(coreResource);
}
/// <summary>
/// Creates header element
/// </summary>
/// <param name="resource"> resource object</param>
/// <returns> instance of XElement </returns>
internal XElement GetHeaderElement(Core.Resource resource)
{
XElement header = null;
header = new XElement(Header);
header.Add(MetadataProviderHelper.GetElement(Header_Identifier, resource.Id.ToString()));
header.Add(MetadataProviderHelper.GetElement(Header_DateStamp, resource.DateModified.Value.ToString(MetadataProviderHelper.DateTimeGranularity, CultureInfo.InvariantCulture)));
ResourceType resourceTypeInfo = new CoreHelper(entityConnectionString).GetResourceType(resource);
if (resourceTypeInfo != null)
{
List <string> listOfResourceTypeInfo = new CoreHelper(entityConnectionString).GetResourceTypeHierarchy(resourceTypeInfo);
listOfResourceTypeInfo.ForEach(delegate(string resourceType)
{
header.Add(MetadataProviderHelper.GetElement(Header_SetSpec, resourceType));
});
}
return(header);
}
private static List <Core.Resource> FilterResources <T>(
IQueryable <T> query,
bool isListRecords) where T : Core.Resource
{
List <Core.Resource> listOfResources = new List <Core.Resource>();
foreach (T resource in query)
{
if (resource is ScholarlyWorks.Contact || resource is Identity || resource is Group)
{
continue;
}
Core.Resource resourceToAdd = resource;
listOfResources.Add(resourceToAdd);
}
if (isListRecords)
{
listOfResources = CoreHelper.LoadResources(listOfResources);
}
return(listOfResources);
}
/// <summary>
/// Creates metadata element
/// </summary>
/// <param name="resource"> resource object </param>
/// <returns> an instance of XElement </returns>
internal static XElement GetMetadataElement(Core.Resource resource)
{
XElement metadata = null;
metadata = new XElement(Metadata);
if (!String.IsNullOrEmpty(resource.Title))
{
metadata.Add(MetadataProviderHelper.GetElement(Metadata_Title, resource.Title));
}
ScholarlyWorks.ScholarlyWork scholarlyWorks = resource as ScholarlyWorks.ScholarlyWork;
if (null != scholarlyWorks)
{
if (scholarlyWorks.Authors != null)
{
MetadataProviderHelper.AddResourceAuthors(metadata, scholarlyWorks);
}
if (scholarlyWorks.Contributors != null)
{
MetadataProviderHelper.AddResourceContributors(metadata, scholarlyWorks);
}
}
// TODO : 2.Currently Tags for a given resource are retrieved without
// checking any relationships, but the implementation needs to be changed if required
ScholarlyWorks.ScholarlyWorkItem scholarlyWorkItem = resource as ScholarlyWorks.ScholarlyWorkItem;
if (scholarlyWorkItem != null && scholarlyWorkItem.Tags != null)
{
MetadataProviderHelper.AddResourceTags(metadata, scholarlyWorkItem);
}
metadata.Add(MetadataProviderHelper.GetElement(Metadata_Description, resource.Description));
if (!String.IsNullOrEmpty(resource.DateModified.Value.ToString()))
{
metadata.Add(MetadataProviderHelper.GetElement(Metadata_Date, resource.DateModified.Value.ToString(DateTimeGranularity, CultureInfo.InvariantCulture)));
}
return(metadata);
}
public override bool ShouldExecute(Type itemType, Core.ItemIdentifier itemId, Core.Resource resource, Core.Enums.ItemEvent eventType)
{
//if (itemType == typeof(Template) && resource.PackageFromPath.ToLower().EndsWith(".master"))
//return true;
return(false);
}
