public IUserGroup?Get(string alias) { try { // need to do a simple query to get the id - put this cache var id = IsolatedCache.GetCacheItem(GetByAliasCacheKey(alias), () => { var groupId = Database.ExecuteScalar <int?>("SELECT id FROM umbracoUserGroup WHERE userGroupAlias=@alias", new { alias }); if (groupId.HasValue == false) { throw new InvalidOperationException("No group found with alias " + alias); } return(groupId.Value); }); // return from the normal method which will cache return(Get(id)); } catch (InvalidOperationException) { // if this is caught it's because we threw this in the caching method return(null); } }
/// <summary> /// This is the underlying method that processes most queries for this repository /// </summary> /// <param name="sqlFull"> /// The full SQL to select all member data /// </param> /// <param name="pagingSqlQuery"> /// The Id SQL to just return all member ids - used to process the properties for the member item /// </param> /// <param name="withCache"></param> /// <returns></returns> private IEnumerable <IMember> ProcessQuery(Sql sqlFull, PagingSqlQuery pagingSqlQuery, bool withCache = false) { // fetch returns a list so it's ok to iterate it in this method var dtos = Database.Fetch <MemberDto, ContentVersionDto, ContentDto, NodeDto>(sqlFull); //This is a tuple list identifying if the content item came from the cache or not var content = new List <Tuple <IMember, bool> >(); var defs = new DocumentDefinitionCollection(); foreach (var dto in dtos) { // if the cache contains the item, use it if (withCache) { var cached = IsolatedCache.GetCacheItem <IMember>(GetCacheIdKey <IMember>(dto.NodeId)); //only use this cached version if the dto returned is the same version - this is just a safety check, members dont //store different versions, but just in case someone corrupts some data we'll double check to be sure. if (cached != null && cached.Version == dto.ContentVersionDto.VersionId) { content.Add(new Tuple <IMember, bool>(cached, true)); continue; } } // else, need to fetch from the database // content type repository is full-cache so OK to get each one independently var contentType = _memberTypeRepository.Get(dto.ContentVersionDto.ContentDto.ContentTypeId); // need properties if (defs.AddOrUpdate(new DocumentDefinition(dto.ContentVersionDto, contentType))) { content.Add(new Tuple <IMember, bool>(MemberFactory.BuildEntity(dto, contentType), false)); } } // load all properties for all documents from database in 1 query var propertyData = GetPropertyCollection(pagingSqlQuery, defs); // assign property data foreach (var contentItem in content) { var cc = contentItem.Item1; var fromCache = contentItem.Item2; //if this has come from cache, we do not need to build up it's structure if (fromCache) { continue; } cc.Properties = propertyData[cc.Version]; //on initial construction we don't want to have dirty properties tracked // http://issues.umbraco.org/issue/U4-1946 cc.ResetDirtyProperties(false); } return(content.Select(x => x.Item1).ToArray()); }
private IEnumerable <IMember> MapDtosToContent(List <MemberDto> dtos, bool withCache = false) { var temps = new List <TempContent <Member> >(); var contentTypes = new Dictionary <int, IMemberType?>(); var content = new Member[dtos.Count]; for (var i = 0; i < dtos.Count; i++) { MemberDto dto = dtos[i]; if (withCache) { // if the cache contains the (proper version of the) item, use it IMember?cached = IsolatedCache.GetCacheItem <IMember>(RepositoryCacheKeys.GetKey <IMember, int>(dto.NodeId)); if (cached != null && cached.VersionId == dto.ContentVersionDto.Id) { content[i] = (Member)cached; continue; } } // else, need to build it // get the content type - the repository is full cache *but* still deep-clones // whatever comes out of it, so use our own local index here to avoid this var contentTypeId = dto.ContentDto.ContentTypeId; if (contentTypes.TryGetValue(contentTypeId, out IMemberType? contentType) == false) { contentTypes[contentTypeId] = contentType = _memberTypeRepository.Get(contentTypeId); } Member c = content[i] = ContentBaseFactory.BuildEntity(dto, contentType); // need properties var versionId = dto.ContentVersionDto.Id; temps.Add(new TempContent <Member>(dto.NodeId, versionId, 0, contentType, c)); } // load all properties for all documents from database in 1 query - indexed by version id IDictionary <int, PropertyCollection> properties = GetPropertyCollections(temps); // assign properties foreach (TempContent <Member> temp in temps) { if (temp.Content is not null) { temp.Content.Properties = properties[temp.VersionId]; // reset dirty initial properties (U4-1946) temp.Content.ResetDirtyProperties(false); } } return(content); }
private PreValueCollection GetCachedPreValueCollection(int datetypeId) { var key = GetPrefixedCacheKey(datetypeId); return(IsolatedCache.GetCacheItem <PreValueCollection>(key, () => { var dtos = Database.Fetch <DataTypePreValueDto>("WHERE datatypeNodeId = @Id", new { Id = datetypeId }); var list = dtos.Select(x => new Tuple <PreValue, string, int>(new PreValue(x.Id, x.Value, x.SortOrder), x.Alias, x.SortOrder)).ToList(); var collection = PreValueConverter.ConvertToPreValuesCollection(list); return collection; }, TimeSpan.FromMinutes(20), isSliding: true)); }
public IMemberGroup GetByName(string name) { return(IsolatedCache.GetCacheItem <IMemberGroup>( typeof(IMemberGroup).FullName + "." + name, () => { var qry = Query <IMemberGroup>().Where(group => group.Name.Equals(name)); var result = Get(qry); return result.FirstOrDefault(); }, //cache for 5 mins since that is the default in the Runtime app cache TimeSpan.FromMinutes(5), //sliding is true true)); }
public IMemberGroup GetByName(string name) { return(IsolatedCache.GetCacheItem <IMemberGroup>( string.Format("{0}.{1}", typeof(IMemberGroup).FullName, name), () => { var qry = new Query <IMemberGroup>().Where(group => group.Name.Equals(name)); var result = GetByQuery(qry); return result.FirstOrDefault(); }, //cache for 5 mins since that is the default in the RuntimeCacheProvider TimeSpan.FromMinutes(5), //sliding is true true)); }