protected override void PerformDelete <T>(HiveId id)
{
Mandate.ParameterNotEmpty(id, "id");
var file = this.Get <File>(id);
if (file == null)
{
throw new IOException(
string.Format("File with id '{0}' does not exist in this providers storage location", id));
}
if (!file.IsContainer)
{
System.IO.File.Delete(file.RootedPath);
}
else
{
System.IO.Directory.Delete(file.RootedPath, true);
}
// Delete any relations
var entityMd5 = id.Value.ToString().ToMd5();
var searchPattern = "*" + entityMd5 + "*.xml";
if (Directory.Exists(Settings.RelationsStoragePath))
{
var files = Directory.GetFiles(Settings.RelationsStoragePath, searchPattern);
foreach (var filePath in files)
{
System.IO.File.Delete(filePath);
}
}
}
public ActionResult EditRule(HiveId id)
{
Mandate.ParameterNotEmpty(id, "id");
//The rule Id consists of both the stylesheet Id and the rule name
var idParts = id.StringParts().ToList();
var stylesheetId = idParts[0];
var ruleName = idParts.Count > 1 ? idParts[1] : "";
ViewBag.IsNew = string.IsNullOrWhiteSpace(ruleName);
using (var uow = _hive.Create())
{
var stylesheet = uow.Repositories.Get <Umbraco.Framework.Persistence.Model.IO.File>(new HiveId(stylesheetId));
var rule = !string.IsNullOrWhiteSpace(ruleName) ?
StylesheetHelper.ParseRules(stylesheet).Single(x => x.Name.Replace(" ", "__s__") == ruleName) :
new StylesheetRule()
{
StylesheetId = id
};
var ruleModel = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <StylesheetRuleEditorModel>(rule);
return(View(ruleModel));
}
}
public override EntitySnapshot <TEntity> PerformGetLatestSnapshot <TEntity>(HiveId hiveId, RevisionStatusType revisionStatusType = null)
{
Mandate.ParameterNotEmpty(hiveId, "hiveId");
var latestRevision = GetLatestRevision <TEntity>(hiveId, revisionStatusType);
if (latestRevision == null)
{
return(null);
}
//IEnumerable<Revision<TEntity>> revisions = GetAll<TEntity>(hiveId, revisionStatusType);
//if (!revisions.Any()) return null;
//if (revisionStatusType != null)
// revisions = revisions.Where(x => x.MetaData.StatusType.Id == revisionStatusType.Id);
//var revision = revisions.OrderByDescending(x => x.MetaData.UtcStatusChanged).FirstOrDefault();
IEnumerable <RevisionData> otherRevisionData = GetAllRevisionData(hiveId);
return(new EntitySnapshot <TEntity>(latestRevision, otherRevisionData));
}
public void Delete <T>(HiveId entityId)
{
Mandate.ParameterNotEmpty(entityId, "entityId");
var file = GetEntity <File>(entityId);
if (file == null)
{
throw new IOException(
string.Format("File with id '{0}' does not exist in this providers storage location", entityId));
}
if (!file.IsContainer)
{
System.IO.File.Delete(file.Location);
}
else
{
System.IO.Directory.Delete(file.Location, true);
}
// Delete any relations
var entityMd5 = entityId.ToString().ToMd5();
var searchPattern = "*" + entityMd5 + "*.xml";
if (Directory.Exists(_relationsFolder))
{
var files = Directory.GetFiles(_relationsFolder, searchPattern);
foreach (var filePath in files)
{
System.IO.File.Delete(filePath);
}
}
}
private IEnumerable <RevisionData> GetAllRevisionData(HiveId entityUri)
{
Mandate.ParameterNotEmpty(entityUri, "hiveId");
//var entityStatusLog = Helper.NhSession.QueryOver<NodeVersionStatusHistory>()
// .OrderBy(x => x.Date).Desc
// .JoinQueryOver(x => x.NodeVersion).Where(x => x.Node.Id == (Guid)entityUri.Value)
// .List()
// .DistinctBy(x => x.Id);
NodeVersionStatusHistory aliasHistory = null;
NodeVersion aliasVersion = null;
Node aliasNode = null;
NodeVersionStatusType aliasType = null;
var entityStatusLog = Helper.NhSession.QueryOver <NodeVersionStatusHistory>(() => aliasHistory)
.OrderBy(x => x.Date).Desc
.JoinQueryOver(x => x.NodeVersionStatusType, () => aliasType)
.JoinQueryOver(x => aliasHistory.NodeVersion, () => aliasVersion)
.JoinQueryOver(x => x.Node, () => aliasNode)
.Where(x => x.Id == (Guid)entityUri.Value)
.Fetch(x => aliasHistory.NodeVersionStatusType).Eager
.Select(x => x.Date, x => x.Id, x => aliasNode.DateCreated, x => aliasType.Id, x => aliasType.IsSystem, x => aliasType.Alias, x => aliasType.Name, x => aliasVersion.Id)
.List <object[]>()
.Select(col => new
{
Date = (DateTimeOffset)col[0],
Id = (Guid)col[1],
DateCreated = (DateTimeOffset)col[2],
TypeId = (Guid)col[3],
TypeIsSystem = (bool)col[4],
TypeAlias = (string)col[5],
TypeName = (string)col[6],
VersionId = (Guid)col[7]
});
var otherRevisionData = new HashSet <RevisionData>();
var changeset = new Changeset(new Branch("default")); // Ignored for the moment in the persistence layer for this provider
foreach (var statusQueryRow in entityStatusLog)
{
var nodeVersionStatusType = new NodeVersionStatusType
{
Alias = statusQueryRow.TypeAlias,
Name = statusQueryRow.TypeName,
Id = statusQueryRow.TypeId,
IsSystem = statusQueryRow.TypeIsSystem
};
var revisionStatusType = FrameworkContext.TypeMappers.Map <RevisionStatusType>(nodeVersionStatusType);
var revisionData = new RevisionData(changeset, (HiveId)statusQueryRow.VersionId, revisionStatusType)
{
UtcCreated = statusQueryRow.DateCreated,
UtcModified = statusQueryRow.Date,
UtcStatusChanged = statusQueryRow.Date
};
otherRevisionData.Add(revisionData);
}
return(otherRevisionData);
}
/// <summary>
/// Gets a revision matching the revision id, entity id and entity type
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="entityId"></param>
/// <param name="revisionId"></param>
/// <returns></returns>
public Revision <TEntity> PerformGetRevision <TEntity>(HiveId entityId, HiveId revisionId)
where TEntity : class, IVersionableEntity
{
Mandate.ParameterNotEmpty(entityId, "entityId");
Mandate.ParameterNotEmpty(revisionId, "revisionId");
var key = ScopedCacheKey + "PerformGetRevision-" +
(typeof(TEntity).FullName + entityId.Value + revisionId.Value).ToMd5();
return(GetOrCreateFromScopedCache <Revision <TEntity> >(key, () =>
{
var criteria = ExamineManager.CreateSearchCriteria()
.Must().HiveId(revisionId, FixedRevisionIndexFields.RevisionId)
.Must().HiveId(entityId, FixedIndexedFields.EntityId)
.Must().EntityType <TEntity>();
var result = ExamineManager.Search(criteria.Compile());
if (result.TotalItemCount > 1)
{
throw new IndexOutOfRangeException("The search result returned more than one item");
}
if (result.TotalItemCount == 0)
{
return null;
}
return _frameworkContext.TypeMappers.Map <Revision <TEntity> >(result.Single());
}));
}
/// <summary>
/// Enlists the id of an <see cref="IRelatableEntity"/> in a <see cref="RelationProxy"/> as a parent of the <see cref="IRelatableEntity"/> which owns this collection.
/// </summary>
/// <param name="parentId">The parent id.</param>
/// <param name="type">The type.</param>
/// <param name="ordinal">The ordinal.</param>
/// <param name="metaData">The meta data.</param>
public void EnlistParentById(HiveId parentId, AbstractRelationType type, int ordinal = 0, params RelationMetaDatum[] metaData)
{
Mandate.ParameterNotEmpty(parentId, "parentId");
var newRelation = new Relation(type, parentId, _collectionOwner, ordinal, metaData);
AddToParentsWithLock(new RelationProxy(newRelation, RelationProxyStatus.ManuallyAdded));
}
public ActionResult EditForm(HiveId?id)
{
Mandate.ParameterNotEmpty(id, "id");
using (var uow = Hive.Create <ISecurityStore>())
{
var userEntity = uow.Repositories.Get <User>(id.Value);
if (userEntity == null)
{
throw new ArgumentException(string.Format("No entity for id: {0} on action EditForm", id));
}
var userViewModel = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <User, UserEditorModel>(userEntity);
userViewModel.UserGroups =
uow.Repositories.GetParentRelations(userEntity.Id, FixedRelationTypes.UserGroupRelationType).Select
(x => x.SourceId).ToArray();
//need to ensure that all of the Ids are mapped correctly, when editing existing content the only reason for this
//is to ensure any new document type properties that have been created are reflected in the new content revision
ReconstructModelPropertyIds(userViewModel);
EnsureViewBagData();
return(ProcessSubmit(userViewModel, userEntity));
}
}
/// <summary>
/// Enlists the id of an <see cref="IRelatableEntity"/> in a <see cref="RelationProxy"/> as a child of the <see cref="IRelatableEntity"/> which owns this collection.
/// </summary>
/// <param name="childId">The child id.</param>
/// <param name="type">The type.</param>
/// <param name="ordinal">The ordinal.</param>
/// <param name="metaData">The meta data.</param>
public void EnlistChildById(HiveId childId, AbstractRelationType type, int ordinal, params RelationMetaDatum[] metaData)
{
Mandate.ParameterNotEmpty(childId, "childId");
var newRelation = new Relation(type, _collectionOwner, childId, ordinal, metaData);
AddToChildrenWithLock(new RelationProxy(newRelation, RelationProxyStatus.ManuallyAdded));
}
public ActionResult EditForm(HiveId?id)
{
Mandate.ParameterNotEmpty(id, "id");
using (var uow = Hive.Create <IContentStore>())
{
var item = uow.Repositories.Schemas.GetComposite <EntitySchema>(id.Value);
if (item == null)
{
throw new ArgumentException(string.Format("No document type found for id: {0} on action EditForm", id));
}
//create a editor model from it and map properties
var model = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <EntitySchema, TEditorModel>(item);
OnBeforeUpdate(model); //TODO: Make this an event/task?
var redirectResult = ProcessSubmit(model, item, uow);
uow.Complete();
//Path generation needs to happen in a new unit of work to ensure update of relations
using (var uow2 = Hive.Create <IContentStore>())
{
//add path for entity for SupportsPathGeneration (tree syncing) to work
GeneratePathsForCurrentEntity(uow2.Repositories.Schemas.GetEntityPaths <EntitySchema>(id.Value, FixedRelationTypes.DefaultRelationType));
}
return(redirectResult);
}
}
public ActionResult CreateNewForm(CreateUserModel createModel)
{
Mandate.ParameterNotNull(createModel, "createModel");
Mandate.ParameterNotEmpty(createModel.ParentId, "createModel.ParentId");
Mandate.ParameterNotEmpty(createModel.SelectedDocumentTypeId, "createModel.SelectedDocumentTypeId");
//validate the model
TryUpdateModel(createModel);
//get the create new result view which will validate that the selected doc type id is in fact allowed
var result = CreateNewView(createModel);
//if at this point the model state is invalid, return the result which is the CreateNew view
if (!ModelState.IsValid)
{
return(result);
}
using (var uow = BackOfficeRequestContext.Application.Hive.OpenReader <IContentStore>())
{
var schema = uow.Repositories.Schemas.GetComposite <EntitySchema>(createModel.SelectedDocumentTypeId);
if (schema == null)
{
throw new ArgumentException(string.Format("No schema found for id: {0} on action Create", createModel.SelectedDocumentTypeId));
}
//create the empty content item
var userViewModel = CreateNewUserEntity(schema, createModel.Name, createModel.Username, createModel.Email, createModel.Password, createModel.ParentId);
//map the Ids correctly to the model so it binds
ReconstructModelPropertyIds(userViewModel);
return(ProcessSubmit(createModel, userViewModel, null));
//return View(createModel);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RelationById"/> class.
/// </summary>
/// <param name="sourceId">The source id.</param>
/// <param name="destinationId">The destination id.</param>
/// <param name="relationType">Type of the relation.</param>
/// <param name="ordinal">The ordinal.</param>
/// <param name="metaData">The meta data.</param>
public RelationById(HiveId sourceId, HiveId destinationId, AbstractRelationType relationType, int ordinal, params RelationMetaDatum[] metaData)
: this(relationType, ordinal, metaData)
{
Mandate.ParameterNotEmpty(sourceId, "sourceId");
Mandate.ParameterNotEmpty(destinationId, "destinationId");
_sourceId = sourceId;
_destinationId = destinationId;
Ordinal = ordinal;
}
public virtual UmbracoTreeResult Index(HiveId id, FormCollection querystrings)
{
Mandate.ParameterNotEmpty(id, "id");
//if its the root node, render it otherwise render normal nodes
return(AddRootNodeToCollection(id, querystrings)
? UmbracoTree()
: GetTreeData(id, querystrings));
}
public override IEnumerable <Revision <TEntity> > PerformGetLatestRevisions <TEntity>(bool allOrNothing, RevisionStatusType revisionStatusType = null, params HiveId[] entityIds)
{
Mandate.ParameterNotNull(entityIds, "entityIds");
entityIds.ForEach(x => Mandate.ParameterNotEmpty(x, "entityIds"));
Guid[] nodeIds = entityIds.Where(x => x.Value.Type == HiveIdValueTypes.Guid).Select(x => (Guid)x.Value).ToArray();
var revisions = Helper.GetNodeVersionsByStatusDesc(nodeIds, revisionStatusType, true).Distinct();
return(nodeIds.Select(x => revisions.SingleOrDefault(y => y.Node.Id == x)).WhereNotNull().Select(x => FrameworkContext.TypeMappers.Map <Revision <TEntity> >(x)));
}
public virtual JsonResult LanguageForm(LanguageModel model)
{
Mandate.ParameterNotEmpty(model.Id, "Id");
using (var uow = Hive.Create <IContentStore>())
{
//get the content entity for the language assignment
var entity = uow.Repositories.Get <TypedEntity>(model.Id);
if (entity == null)
{
throw new NullReferenceException("Could not find entity with id " + model.Id);
}
var languageRelations = uow.Repositories.GetParentRelations(model.Id, FixedRelationTypes.LanguageRelationType);
var languageRelation = languageRelations.SingleOrDefault();
if (model.IsoCode.IsNullOrWhiteSpace())
{
if (languageRelation != null)
{
uow.Repositories.RemoveRelation(languageRelation);
}
}
else
{
if (languageRelation == null || languageRelation.MetaData.SingleOrDefault(x => x.Key == "IsoCode").Value != model.IsoCode)
{
var metaData = new List <RelationMetaDatum>
{
new RelationMetaDatum("IsoCode", model.IsoCode)
};
uow.Repositories.ChangeOrCreateRelationMetadata(FixedHiveIds.SystemRoot, entity.Id,
FixedRelationTypes.LanguageRelationType, metaData.ToArray());
}
}
uow.Complete();
//clears the domain cache
//BackOfficeRequestContext.RoutingEngine.ClearCache(clearDomains: true, clearGeneratedUrls: true);
var successMsg = "Language.Success.Message".Localize(this, new
{
Name = entity.GetAttributeValue(NodeNameAttributeDefinition.AliasValue, "Name")
});
Notifications.Add(new NotificationMessage(successMsg, "Language.Title".Localize(this), NotificationType.Success));
return(new CustomJsonResult(new
{
success = true,
notifications = Notifications,
msg = successMsg
}.ToJsonString));
}
}
/// <summary>
/// Returns a composite Id to be used for a relation
/// </summary>
/// <param name="relation"></param>
/// <returns></returns>
internal static string GetCompositeId(this IRelationById relation)
{
Mandate.ParameterNotEmpty(relation.SourceId, "relation.SourceId");
Mandate.ParameterNotEmpty(relation.DestinationId, "relation.DestinationId");
Mandate.ParameterNotEmpty(relation.SourceId.Value, "relation.SourceId.Value");
Mandate.ParameterNotEmpty(relation.DestinationId.Value, "relation.SourceId.Value");
Mandate.ParameterNotNull(relation.Type, "relation.Type");
Mandate.ParameterNotNullOrEmpty(relation.Type.RelationName, "relation.Type.RelationName");
return(relation.SourceId.Value + "," + relation.DestinationId.Value + "," + relation.Type.RelationName);
}
/// <summary>
/// constructor for creating a property that has a multi-value
/// </summary>
/// <param name="id"></param>
/// <param name="docTypeProperty">The DocumentTypeProperty associated with this content property</param>
/// <param name="propertyValue">The value of the property, used to set the values of the editor model</param>
public ContentProperty(HiveId id,
DocumentTypeProperty docTypeProperty,
IDictionary <string, object> propertyValue)
{
Mandate.ParameterNotEmpty(id, "id");
Mandate.ParameterNotNull(docTypeProperty, "docTypeProperty");
_propertyValue = propertyValue;
Id = id;
DocTypeProperty = docTypeProperty;
DocTypePropertyId = docTypeProperty.Id;
}
/// <summary>
/// Creates a data type
/// </summary>
/// <param name="id"></param>
/// <param name="name"></param>
/// <param name="alias"></param>
/// <param name="propertyEditor">The PropertyEditor associated with the DataType</param>
/// <param name="preValues">The pre values stored in the repository for the DataType</param>
public DataType(HiveId id, string name, string alias, dynamic propertyEditor, string preValues)
{
Mandate.ParameterNotEmpty(id, "id");
Mandate.ParameterNotNullOrEmpty(name, "name");
Mandate.ParameterNotNullOrEmpty(alias, "alias");
//Mandate.ParameterNotNull(propertyEditor, "propertyEditor");
Name = name;
Alias = alias;
InternalPropertyEditor = propertyEditor;
Prevalues = preValues;
}
protected override IEnumerable <TEntity> PerformGet <TEntity>(bool allOrNothing, params HiveId[] ids)
{
Mandate.ParameterNotNull(ids, "ids");
ids.ForEach(x => Mandate.ParameterNotEmpty(x, "id"));
Type destinationType = GetDestinationTypeOrThrow <TEntity>();
Guid[] values = ids.Where(x => x.Value.Type == HiveIdValueTypes.Guid).Select(x => (Guid)x.Value).ToArray();
var entities = Helper.NhSession.CreateCriteria(destinationType).Add(Restrictions.In(Projections.Property <Node>(x => x.Id), values)).List();
return(entities.Cast <IReferenceByGuid>().Select(x => FrameworkContext.TypeMappers.Map <TEntity>(x)));
}
public virtual JsonResult Delete(HiveId?id)
{
Mandate.ParameterNotEmpty(id, "id");
using (var uow = Hive.Create <IContentStore>())
{
uow.Repositories.Delete <TypedEntity>(id.Value);
uow.Complete();
}
//return a successful JSON response
return(Json(new { message = "Success" }));
}
public override bool Exists <TEntity>(HiveId id)
{
Mandate.ParameterNotEmpty(id, "id");
var value = (Guid)id.Value;
var qo = Helper.NhSession.QueryOver <AttributeSchemaDefinition>()
.Where(x => x.Id == value)
.Select(Projections.RowCount())
.SingleOrDefault <int>();
return(qo > 0);
}
public JsonResult Delete(HiveId id)
{
Mandate.ParameterNotEmpty(id, "id");
using (var uow = Hive.Create <IContentStore>())
{
uow.Repositories.Schemas.Delete <EntitySchema>(id);
uow.Complete();
}
//return a successful JSON response
return(Json(new { message = "Success" }));
}
public virtual JsonResult Delete(HiveId id)
{
Mandate.ParameterNotEmpty(id, "id");
using (var uow = Hive.Create())
{
uow.Repositories.Delete <File>(id);
uow.Complete();
}
//return a successful JSON response
return(Json(new { message = "Success" }));
}
public override IEnumerable <T> PerformGet <T>(bool allOrNothing, params HiveId[] ids)
{
Mandate.ParameterNotNull(ids, "ids");
ids.ForEach(x => Mandate.ParameterNotEmpty(x, "id"));
// We don't just ask for the Node by id here because some other types inherit from Node
// like AttributeSchemaDefinition. Therefore, a Node that represents a TypedEntity is said
// to exist if a NodeVersion exists
Guid[] nodeIds = ids.Where(x => x.Value.Type == HiveIdValueTypes.Guid).Select(x => (Guid)x.Value).ToArray();
var nodeVersions = Helper.GetNodeVersionsByStatusDesc(nodeIds, limitToLatestRevision: true).ToArray();
return(nodeIds.Select(x => nodeVersions.SingleOrDefault(y => y.Node.Id == x)).WhereNotNull().Select(x => FrameworkContext.TypeMappers.Map <T>(x)));
}
/// <summary>
/// Resolves the url for the specified id.
/// </summary>
/// <param name="routingEngine"></param>
/// <param name="id">The id.</param>
/// <returns></returns>
public static string GetUrl(this IRoutingEngine routingEngine, HiveId id)
{
Mandate.ParameterNotEmpty(id, "id");
var applicationContext = DependencyResolver.Current.GetService <IRebelApplicationContext>();
var hive = applicationContext.Hive.GetReader <IContentStore>(id.ToUri());
if (hive != null)
{
var key = CacheKey.Create(new UrlCacheKey(id));
var item = hive.HiveContext.GenerationScopedCache.GetOrCreate(key, () =>
{
using (var uow = hive.CreateReadonly())
{
//var entity = uow.Repositories.Get<TypedEntity>(id);
var entity = uow.Repositories.OfRevisionType(FixedStatusTypes.Published).InIds(id).FirstOrDefault();
if (entity == null)
{
throw new NullReferenceException("Could not find a TypedEntity in the repository for a content item with id " + id.ToFriendlyString());
}
return(routingEngine.GetUrlForEntity(entity));
}
});
var urlResult = item.Value.Item;
////return from scoped cache so we don't have to lookup in the same session
//var urlResult = applicationContext.FrameworkContext.ScopedCache.GetOrCreateTyped<UrlResolutionResult>("nice-url-" + id, () =>
// {
// using (var uow = hive.CreateReadonly())
// {
// var entity = uow.Repositories.Get<TypedEntity>(id);
// if (entity == null)
// throw new NullReferenceException("Could not find a TypedEntity in the repository for a content item with id " + id.ToFriendlyString());
// return routingEngine.GetUrlForEntity(entity);
// }
// });
if (urlResult.IsSuccess())
{
return(urlResult.Url);
}
//return a hashed url with the status
return("#" + urlResult.Status);
}
return(id.ToString());
}
/// <summary>
/// Gets entities matching the id
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="allOrNothing">if set to <c>true</c> [all or nothing].</param>
/// <param name="idField">The id field to search on</param>
/// <param name="ids">The ids.</param>
/// <returns></returns>
public IEnumerable <T> PerformGet <T>(bool allOrNothing, string idField, params HiveId[] ids)
{
Mandate.ParameterNotNull(ids, "ids");
ids.ForEach(x => Mandate.ParameterNotEmpty(x, "id"));
var key = ScopedCacheKey + "PerformGet-" +
(typeof(T).FullName + allOrNothing + idField + string.Join(".", ids.Select(x => x.Value))).ToMd5();
return(GetOrCreateFromScopedCache <IEnumerable <T> >(key, () =>
{
//NOTE: Because of allOrNothing, we can't yield return anything.
var toReturn = new List <T>();
foreach (var i in ids)
{
IQuery criteria;
if (TypeFinder.IsTypeAssignableFrom <TypedEntity>(typeof(T)))
{
criteria = ExamineManager.CreateSearchCriteria()
.Must().HiveId(i, idField)
.Must().Range(FixedRevisionIndexFields.IsLatest, 1, 1)
.Must().EntityType <T>().Compile();
}
else
{
//anything else...
criteria = ExamineManager.CreateSearchCriteria()
.Must().HiveId(i, idField)
.Must().EntityType <T>().Compile();
}
// NOTE: We currently return the 'newest', not sure if that is the correct approach. SD.
var result = ExamineManager.Search(criteria)
.OrderBy(x => x.Fields[FixedIndexedFields.UtcModified])
.LastOrDefault();
if (result == null)
{
if (allOrNothing)
{
return Enumerable.Empty <T>();
}
}
var mapped = _frameworkContext.TypeMappers.Map <T>(result);
toReturn.Add(mapped);
}
return toReturn;
}));
}
/// <summary>
/// Creates a new TEditorModel based on the persisted doc type
/// </summary>
/// <param name="docTypeData"></param>
/// <param name="name"></param>
/// <param name="parentId"></param>
/// <returns></returns>
protected virtual TEditorModel CreateNewContentEntity(EntitySchema docTypeData, string name, HiveId parentId)
{
Mandate.ParameterNotNull(docTypeData, "docTypeData");
Mandate.ParameterNotEmpty(parentId, "parentId");
//get doc type model
var docType = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <EntitySchema, DocumentTypeEditorModel>(docTypeData);
//map (create) content model from doc type model
var contentModel = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <DocumentTypeEditorModel, TEditorModel>(docType);
contentModel.ParentId = parentId;
contentModel.Name = name;
return(contentModel);
}
public virtual JsonResult Delete(HiveId?id)
{
Mandate.ParameterNotEmpty(id, "id");
using (var uow = _hive.Create())
{
var oldFolder = uow.Repositories.Get <Rebel.Framework.Persistence.Model.IO.File>(id.Value);
if (oldFolder != null)
{
uow.Repositories.Delete <Rebel.Framework.Persistence.Model.IO.File>(oldFolder.Id);
}
}
//return a successful JSON response
return(Json(new { message = "Success" }));
}
public FileEditorModel(HiveId id, string name, DateTimeOffset created, DateTimeOffset updated, Func <string> content)
{
Mandate.ParameterNotEmpty(id, "id");
Mandate.ParameterNotNullOrEmpty(name, "name");
Mandate.ParameterNotNull(content, "content");
Id = id;
UtcCreated = created;
UtcModified = updated;
Name = name;
FileContent = content();
PopulateUIElements();
}
public override EntitySnapshot <TEntity> GetSnapshot <TEntity>(HiveId hiveId, HiveId revisionId)
{
Mandate.ParameterNotEmpty(hiveId, "hiveId");
Mandate.ParameterNotEmpty(revisionId, "revisionId");
var revision = Get <TEntity>(hiveId, revisionId);
if (revision == null)
{
return(null);
}
IEnumerable <RevisionData> otherRevisionData = GetAllRevisionData(hiveId);
return(new EntitySnapshot <TEntity>(revision, otherRevisionData));
}