Select a site

IMPORTANT: This version of Sitefinity CMS is out of support and the respective product documentation is no longer maintained and can be outdated. Use the version selector to view a supported product version.

Locations module: Implement the OpenAccess data provider

After you Locations module: Create the data persistent class, you need to implement the the OpenAccess data provider that the Locations module implementation uses. The OpenAccess data provider must inherit and implement the abstract LocationsDataProvider class.

To create an OpenAccess data provider:

  1. In Visual Studio, navigate to LocationsModule project » Data folder and open the context menu of OpenAccess.
    Click Add » Class.
  2. Name the class file OpenAccessLocationsDataProvider.cs and click Add.
  3. Open the file OpenAccessLocationsDataProvider.cs.
  4. Add the following using statements:
    • using LocationsModule.Model;
    • using Telerik.OpenAccess.Metadata;
    • using Telerik.Sitefinity.Data;
    • using Telerik.Sitefinity.Data.Linq;
    • using Telerik.Sitefinity.Data.Linq.Dynamic;
    • using Telerik.Sitefinity.GenericContent.Model;
    • using Telerik.Sitefinity.Model;
    • using Telerik.Sitefinity.Modules.GenericContent;
    • using Telerik.Sitefinity.Modules.GenericContent.Data;
    • using Telerik.Sitefinity.Security;
  5. Make the OpenAccessLocationsDataProvider class inherit the ContentDataProviderBase class and implement the IOpenAccessDataProvider interface:
    public class OpenAccessLocationsDataProvider : ContentDataProviderBase, IOpenAccessDataProvider
    {
    }
  6. To implement the ContentDataProviderBase class you must have the following members:
    • RootKey - in this property you must store an identifier for the provider.
    • GetParentTypeFor - this method is used for modules with parent-child relationships, such as Lists and List Items, and Blogs and Blog Posts. If the module does not have such relationship, you must return null.
    • GetUrlTypeFor - in this method, you must return the UrlData implementation created for the persistent class.
    • GetUrlFormat - in this method, you must return the regular expression used to format the LocationItem URL.
    • GetKnownTypes - in this method you must return a list of types that your provider handles.
    • GetItemsByTaxon - this method allows you to retrieve LocationItem objects by tag or category using the Sitefinity CMS taxonomy system.
    • GetItemFromUrl - this method allows you to retrieve LocationItem objects by their URLs.

    Add the following code to implement these members:

    public override IEnumerable GetItemsByTaxon(Guid taxonId, bool isSingleTaxon, string propertyName, Type itemType, string filterExpression, string orderExpression, int skip, int take, ref int? totalCount)
    {
        if (itemType == typeof(LocationItem))
        {
            this.CurrentTaxonomyProperty = propertyName;
            int? internalTotCount = null;
            IQueryable<LocationItem> query =
                (IQueryable<LocationItem>)this.GetItems(itemType, filterExpression, orderExpression, 0, 0, ref internalTotCount);
            if (isSingleTaxon)
            {
                var query0 = from i in query
                             where i.GetValue<Guid>(this.CurrentTaxonomyProperty) == taxonId
                             select i;
                query = query0;
            }
            else
            {
                var query1 = from i in query
                             where (i.GetValue<IList<Guid>>(this.CurrentTaxonomyProperty)).Any(t => t == taxonId)
                             select i;
                query = query1;
            }
      
            if (totalCount.HasValue)
            {
                totalCount = query.Count();
            }
      
            if (skip > 0)
                query = query.Skip(skip);
            if (take > 0)
                query = query.Take(take);
            return query;
        }
        throw GetInvalidItemTypeException(itemType, this.GetKnownTypes());
    }
      
    public override IDataItem GetItemFromUrl(Type itemType, string url, bool published, out string redirectUrl)
    {
        if (itemType == null)
            throw new ArgumentNullException("itemType");
        if (String.IsNullOrEmpty(url))
            throw new ArgumentNullException("Url");
      
        var urlType = this.GetUrlTypeFor(itemType);
      
        var urlData = this.GetUrls(urlType).Where(u => u.Url == url).FirstOrDefault();
      
        if (urlData != null)
        {
            var item = urlData.Parent;
      
            if (urlData.RedirectToDefault)
                redirectUrl = this.GetItemUrl((ILocatable)item, CultureInfo.GetCultureInfo(urlData.Culture));
            else
                redirectUrl = null;
            if (item != null)
                item.Provider = this;
            return item;
        }
        redirectUrl = null;
        return null;
    }
      
    public override Type GetParentTypeFor(Type contentType)
    {
        return null;
    }
      
    public override Type GetUrlTypeFor(Type itemType)
    {
        if (itemType == typeof(LocationItem)) return typeof(LocationItemUrlData);
      
        throw GetInvalidItemTypeException(itemType, this.GetKnownTypes());
    }
     
    public override string GetUrlFormat(ILocatable item)
    {
        if (item.GetType() == typeof(LocationItem))
        {
            return "/[UrlName]";
        }
     
        return base.GetUrlFormat(item);
    }
      
    public override Type[] GetKnownTypes()
    {
        return new[] { typeof(LocationItem) };
    }
      
    public override string RootKey
    {
        get { return "LocationsDataProvider"; }
    }

     

  7. Create methods for the following operations:
    1. CreateLocation
      public LocationItem CreateLocation()
      {
          return this.CreateLocation(Guid.NewGuid());
      }
      2. public LocationItem CreateLocation(Guid id)
      {
          var location = new LocationItem();
          location.Id = id;
          location.ApplicationName = this.ApplicationName;
          location.Owner = SecurityManager.GetCurrentUserId();
          var dateValue = DateTime.UtcNow;
          location.DateCreated = dateValue;
          location.PublicationDate = dateValue;
          ((IDataItem)location).Provider = this;
       
          // items with empty GUID are used in the UI to get a "blank" data item
          // -> that is, to fill a data item with default values
          // if this is the case, leave the item out of the transaction
          if (id != Guid.Empty)
          {
              this.GetContext().Add(location);
          }
          return location;
      }

    2. GetLocation
      public LocationItem GetLocation(Guid id)
      {
          if (id == Guid.Empty)
              throw new ArgumentException("Id cannot be Empty Guid");
       
          // Always use this method. Do not change it to query. Catch the exception if the ID can be wrong.
          var location = this.GetContext().GetItemById<LocationItem>(id.ToString());
          ((IDataItem)location).Provider = this;
       
          return location;
      }
    3. GetLocations
      public IQueryable<LocationItem> GetLocations()
      {
          var appName = this.ApplicationName;
       
          var query =
              SitefinityQuery
              .Get<LocationItem>(this, MethodBase.GetCurrentMethod())
              .Where(b => b.ApplicationName == appName);
       
          return query;
      }
    4. DeleteLocation
      public void DeleteLocation(LocationItem location)
      {
          var scope = this.GetContext();
       
          //this.ClearLifecycle(location, this.GetLocations());
          if (scope != null)
          {
              scope.Remove(location);
          }
      }
  8. Override the respective methods of the ContentDataProviderBase class and call the abstract methods from the methods:
    public override object GetItemOrDefault(Type itemType, Guid id)
    {
        if (itemType == typeof(Comment))
        {
            return this.GetComments().Where(c => c.Id == id).FirstOrDefault();
        }
     
        if (itemType == typeof(LocationItem))
            return this.GetLocations().Where(n => n.Id == id).FirstOrDefault();
     
        return base.GetItemOrDefault(itemType, id);
    }
     
    public override object CreateItem(Type itemType, Guid id)
    {
        if (itemType == null)
            throw new ArgumentNullException("itemType");
     
        if (itemType == typeof(LocationItem))
        {
            return this.CreateLocation(id);
        }
     
        throw GetInvalidItemTypeException(itemType, this.GetKnownTypes());
    }
     
    public override object GetItem(Type itemType, Guid id)
    {
        if (itemType == null)
            throw new ArgumentNullException("itemType");
     
        if (itemType == typeof(LocationItem))
            return this.GetLocation(id);
     
        return base.GetItem(itemType, id);
    }
     
    public override IEnumerable GetItems(Type itemType, string filterExpression, string orderExpression, int skip, int take, ref int? totalCount)
    {
        if (itemType == null)
            throw new ArgumentNullException("itemType");
     
        if (itemType == typeof(LocationItem))
        {
            return SetExpressions(this.GetLocations(), filterExpression, orderExpression, skip, take, ref totalCount);
        }
     
        if (itemType == typeof(Comment))
        {
            return SetExpressions(this.GetComments(), filterExpression, orderExpression, skip, take, ref totalCount);
        }
     
        throw GetInvalidItemTypeException(itemType, this.GetKnownTypes());
    }
     
    public override void DeleteItem(object item)
    {
        this.DeleteLocation((LocationItem)item);
    }


  9.  Implement the IOpenAccessDataProvider members in the following way:
    public OpenAccessProviderContext Context
    {
        get;
        set;
    }
     
    public MetadataSource GetMetaDataSource(IDatabaseMappingContext context)
    {
        return new LocationsFluentMetadataSource(context);
    }

    The GetMetaDataSource method returns an instance of the ContentBaseMetadataSource implementation that defines the fluent mappings for your module.

  10. Mark the OpenAccessLocationsDataProvider class with the [ContentProviderDecorator(typeof(OpenAccessContentDecorator))] attribute:

    [ContentProviderDecorator(typeof(OpenAccessContentDecorator))]
    public class OpenAccessLocationsDataProvider : ContentDataProviderBase, IOpenAccessDataProvider

     

Back To Top

Next: Locations module: Implement fluent mappings