void IContentPartHandler.Created(CreateContentContext context, ContentPart part) { if (part is TPart) { Created(context, (TPart)part); } }
void IContentHandler.Created(CreateContentContext context) { if (context.ContentItem.Is <TPart>()) { Created(context, context.ContentItem.As <TPart>()); } }
protected override void Created(CreateContentContext context) { // At this point the UpdateEditor hasn't been invoked on the content item yet, // so we don't have access to all of the information we might need (such as Title). // We set a flag which we will check in the Updated method (which is invoked when UpdateEditor is invoked). _contentItemCreated = true; }
public void Created(CreateContentContext context) { if (!string.IsNullOrWhiteSpace(zone) && hostId != context.ContentItem.Id) { hostId = context.ContentItem.Id; } }
void IContentStorageFilter.Created(CreateContentContext context) { if (context.ContentItem.Is <TPart>()) { Created(context, context.ContentItem.As <TPart>()); } }
protected void AssignCreatingOwner(CreateContentContext context, CoeveryCommonPart part) { // and use the current user as Owner if (part.Record.OwnerId == 0) { part.Owner = _authenticationService.GetAuthenticatedUser(); } }
public virtual void Create(ContentItem contentItem, VersionOptions options) { if (contentItem.VersionRecord == null) { // produce root record to determine the model id contentItem.VersionRecord = new ContentItemVersionRecord { ContentItemRecord = new ContentItemRecord { }, Number = 1, Latest = true, Published = true }; } // add to the collection manually for the created case contentItem.VersionRecord.ContentItemRecord.Versions.Add(contentItem.VersionRecord); // version may be specified if (options.VersionNumber != 0) { contentItem.VersionRecord.Number = options.VersionNumber; } // draft flag on create is required for explicitly-published content items if (options.IsDraft) { contentItem.VersionRecord.Published = false; } _contentItemRepository.Create(contentItem.Record); _contentItemVersionRepository.Create(contentItem.VersionRecord); // build a context with the initialized instance to create var context = new CreateContentContext(contentItem); // invoke handlers to add information to persistent stores Handlers.Invoke(handler => handler.Creating(context), Logger); // deferring the assignment of ContentType as loading a Record might force NHibernate to AutoFlush // the ContentPart, and needs the ContentItemRecord to be created before (created in previous statement) contentItem.VersionRecord.ContentItemRecord.ContentType = AcquireContentTypeRecord(contentItem.ContentType); Handlers.Invoke(handler => handler.Created(context), Logger); if (options.IsPublished) { var publishContext = new PublishContentContext(contentItem, null); // invoke handlers to acquire state, or at least establish lazy loading callbacks Handlers.Invoke(handler => handler.Publishing(publishContext), Logger); // invoke handlers to acquire state, or at least establish lazy loading callbacks Handlers.Invoke(handler => handler.Published(publishContext), Logger); } }
public override void Created(CreateContentContext context, FlowPart part) { foreach (var contentItem in part.Widgets) { // Update version number so that IsNew reflects the actual status contentItem.Number = 1; } // Reflect the changes back to the content item part.Apply(); }
public void Create(ContentItem contentItem) { _contentItemRepository.Create(contentItem.Record); // build a context with the initialized instance to create var context = new CreateContentContext(contentItem); // invoke handlers to add information to persistent stores Handlers.Invoke(handler => handler.Creating(context), Logger); Handlers.Invoke(handler => handler.Created(context), Logger); }
public override Task CreatedAsync(CreateContentContext context) { base.CreatedAsync(context).GetAwaiter().GetResult(); var httpContent = _httpContentAccessor.HttpContext; if (httpContent?.User?.Identity?.IsAuthenticated ?? false) { context.ContentItem.Author = _extensionService.FindUser(httpContent.User.Identity.Name) ?.NickName ?? context.ContentItem.Author; } return(Task.CompletedTask); }
protected void AssignCreatingDates(CreateContentContext context, CoeveryCommonPart part) { // assign default create/modified dates part.Container = context.ContentItem; var utcNow = _clock.UtcNow; part.CreatedUtc = utcNow; part.ModifiedUtc = utcNow; part.VersionCreatedUtc = utcNow; part.VersionModifiedUtc = utcNow; }
public override void Creating(CreateContentContext context) { var infosetPart = context.ContentItem.As <InfosetPart>(); if (infosetPart != null) { context.ContentItemRecord.Data = infosetPart.Infoset.Data; context.ContentItemVersionRecord.Data = infosetPart.VersionInfoset.Data; infosetPart.Infoset = context.ContentItemRecord.Infoset; infosetPart.VersionInfoset = context.ContentItemVersionRecord.Infoset; } }
protected override void Created(CreateContentContext context) { var socket = context.ContentItem.As <SocketsPart>(); if (socket != null) { // TODO: But we perhaps don't need to do this since ConnectorCollection tracks removed and added objects, // ideally we can drop this and let everything happen at the end of transaction scope. // If updating, perform connector persistence socket.Sockets.AllSockets.Invoke(c => { c.Connectors.Flush(_mechanics.Value); }, Logger); } base.Created(context); }
public override Task CreatedAsync(CreateContentContext context) { if (_hca.HttpContext.Items.ContainsKey("OrchardCore.AuditTrail.Restored")) { return(RecordAuditTrailEventAsync(ContentAuditTrailEventProvider.Restored, context.ContentItem)); } else if (!context.ContentItem.Published) { return(RecordAuditTrailEventAsync(ContentAuditTrailEventProvider.Created, context.ContentItem)); } return(Task.CompletedTask); }
public virtual void Create(ContentItem contentItem, VersionOptions options) { if (contentItem.VersionRecord == null) { // produce root record to determine the model id contentItem.VersionRecord = new ContentItemVersionRecord { ContentItemRecord = new ContentItemRecord(), Number = 1, Latest = true, Published = true }; } // add to the collection manually for the created case contentItem.VersionRecord.ContentItemRecord.Versions.Add(contentItem.VersionRecord); contentItem.VersionRecord.ContentItemRecord.ContentType = AcquireContentTypeRecord(contentItem.ContentType); // version may be specified if (options.VersionNumber != 0) { contentItem.VersionRecord.Number = options.VersionNumber; } // draft flag on create is required for explicitly-published content items if (options.IsDraft) { contentItem.VersionRecord.Published = false; } _contentItemStore.Store(contentItem); // build a context with the initialized instance to create var context = new CreateContentContext(contentItem); // invoke handlers to add information to persistent stores Handlers.Invoke(handler => handler.Creating(context), _logger); Handlers.Invoke(handler => handler.Created(context), _logger); if (options.IsPublished) { var publishContext = new PublishContentContext(contentItem, null); // invoke handlers to acquire state, or at least establish lazy loading callbacks Handlers.Invoke(handler => handler.Publishing(publishContext), _logger); // invoke handlers to acquire state, or at least establish lazy loading callbacks Handlers.Invoke(handler => handler.Published(publishContext), _logger); } }
public override Task CreatedAsync(CreateContentContext context, PartyPart part) { if (part.PartyType == PartyType.Person) { part.FullName = part.Content.FirstName.ToString() + " " + part.Content.LastName.ToString(); } else if (part.PartyType == PartyType.Organization) { part.FirstName = string.Empty; part.LastName = string.Empty; } part.ContentItem.DisplayText = part.FullName; //part.Apply(); return(Task.CompletedTask); }
protected void AssociateLoyalzooAccount(CreateContentContext context) { //Non eseguo la creazione di un nuovo utente Loyalzoo se chiamo dal pannello di amministrazione di Orchard if (_controllerContextAccessor.Context.Controller.GetType().FullName != "Orchard.Users.Controllers.AdminController") { APIResult accountCreationResult = _fidelityService.CreateLoyalzooAccountFromContext(context); if (accountCreationResult.success == true) { _controllerContextAccessor.Context.Controller.TempData.Add("LoyalzooRegistrationSuccess", true); } else { _controllerContextAccessor.Context.Controller.TempData.Add("LoyalzooRegistrationSuccess", false); } } }
/// <summary> /// Need to override CreatingAsync to set the right parent on Creation. /// This will attach the item to the right list when the item is created from a list of another culture /// </summary> public override async Task CreatingAsync(CreateContentContext context, LocalizationPart instance) { var containedPart = context.ContentItem.As <ContainedPart>(); if (containedPart != null) { var list = await _session.QueryIndex <LocalizedContentItemIndex>(i => (i.Published || i.Latest) && i.ContentItemId == containedPart.ListContentItemId).FirstOrDefaultAsync(); var localizedList = await _session.QueryIndex <LocalizedContentItemIndex>(i => (i.Published || i.Latest) && i.LocalizationSet == list.LocalizationSet && i.Culture == instance.Culture).FirstOrDefaultAsync(); if (localizedList != null) { containedPart.ListContentItemId = localizedList.ContentItemId; containedPart.Apply(); } } }
public virtual void Create(ContentItem contentItem, VersionOptions options) { if (contentItem.Number == 0) { contentItem.Number = 1; contentItem.Latest = true; contentItem.Published = true; } // Version may be specified if (options.VersionNumber != 0) { contentItem.Number = options.VersionNumber; } // Draft flag on create is required for explicitly-published content items if (options.IsDraft) { contentItem.Published = false; } // Build a context with the initialized instance to create var context = new CreateContentContext(contentItem); // invoke handlers to add information to persistent stores Handlers.Invoke(handler => handler.Creating(context), _logger); Handlers.Invoke(handler => handler.Created(context), _logger); if (options.IsPublished) { var publishContext = new PublishContentContext(contentItem, null); // invoke handlers to acquire state, or at least establish lazy loading callbacks Handlers.Invoke(handler => handler.Publishing(publishContext), _logger); // invoke handlers to acquire state, or at least establish lazy loading callbacks Handlers.Invoke(handler => handler.Published(publishContext), _logger); } _session.Save(contentItem); _contentManagerSession.Store(contentItem); }
public void Create(ContentItem contentItem, VersionOptions options) { if (contentItem.Number == 0) { contentItem.Number = 1; contentItem.Latest = true; contentItem.Published = true; } if (String.IsNullOrEmpty(contentItem.ContentItemVersionId)) { contentItem.ContentItemVersionId = _idGenerator.GenerateUniqueId(contentItem); } // Draft flag on create is required for explicitly-published content items if (options.IsDraft) { contentItem.Published = false; } // Build a context with the initialized instance to create var context = new CreateContentContext(contentItem); // invoke handlers to add information to persistent stores Handlers.Invoke(handler => handler.Creating(context), _logger); Handlers.Reverse().Invoke(handler => handler.Created(context), _logger); _session.Save(contentItem); _contentManagerSession.Store(contentItem); if (options.IsPublished) { var publishContext = new PublishContentContext(contentItem, null); // invoke handlers to acquire state, or at least establish lazy loading callbacks Handlers.Invoke(handler => handler.Publishing(publishContext), _logger); // invoke handlers to acquire state, or at least establish lazy loading callbacks Handlers.Reverse().Invoke(handler => handler.Published(publishContext), _logger); } }
public override void Creating(CreateContentContext context) { var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(context.ContentItem.ContentType); if (contentTypeDefinition == null) { return; } foreach (var typePartDefinition in contentTypeDefinition.Parts) { var partName = typePartDefinition.PartDefinition.Name; var partType = _contentPartFactory.GetContentPartType(partName) ?? typeof(ContentPart); var part = context.ContentItem.Get(partType, partName) as ContentPart; if (part != null) { _partHandlers.Invoke(handler => handler.Creating(context, part), Logger); } } }
public override async Task CreatingAsync(CreateContentContext context) { var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(context.ContentItem.ContentType); if (contentTypeDefinition == null) { return; } foreach (var typePartDefinition in contentTypeDefinition.Parts) { var partName = typePartDefinition.PartDefinition.Name; var activator = _contentPartFactory.GetTypeActivator(partName); var part = context.ContentItem.Get(activator.Type, typePartDefinition.Name) as ContentPart; if (part != null) { await _partHandlers.InvokeAsync(async handler => await handler.CreatingAsync(context, part), Logger); } } }
public APIResult CreateLoyalzooAccountFromContext(CreateContentContext context) { try { IUser userPart = context.ContentItem.As <IUser>(); LoyalzooUserPart loyalzooPart = context.ContentItem.As <LoyalzooUserPart>(); if (userPart != null && loyalzooPart != null) { return(CreateLoyalzooAccount(loyalzooPart, userPart.UserName, userPart.Email)); //string userName = ""; //if (userPart.UserName == "testale2") // userName = Guid.NewGuid().ToString(); //else // userName = userPart.UserName; //return CreateLoyalzooAccount(loyalzooPart, userName, userPart.Email); } else { return new APIResult { success = false, data = null, message = "The user is not configured to use Loyalzoo." } }; } catch (Exception e) { APIResult exceptionData = new APIResult(); exceptionData.success = false; exceptionData.message = e.Message; exceptionData.data = null; return(exceptionData); } }
//todo: add log scopes for these operations public override async Task CreatingAsync(CreateContentContext context) { // the presence of this key indicates that a content item is being restored by the audit trail module if (!_httpContextAccessor.HttpContext.Items.ContainsKey("OrchardCore.AuditTrail.Restored")) { return; } try { if (!await _syncOrchestrator.Restore(context.ContentItem)) { // sad paths have already been notified to the user and logged Cancel(context); } } catch (Exception ex) { // we log the exception, even though some exceptions will have already been logged, // as there might have been an 'unexpected' exception thrown _logger.LogError(ex, "Exception saving draft."); Cancel(context); } }
public override Task CreatedAsync(CreateContentContext context) => AddContextAsync(context);
protected override void Creating(CreateContentContext context, TestModelPart instance) { instance.CreatingCalled = true; }
private async Task <ContentValidateResult> CreateContentItemVersionAsync(ContentItem contentItem, IEnumerable <ContentItem> evictionVersions = null) { if (String.IsNullOrEmpty(contentItem.ContentItemId)) { // NewAsync should be used to create new content items. throw new ArgumentNullException(nameof(ContentItem.ContentItemId)); } // Initializes the Id as it could be interpreted as an updated object when added back to YesSql contentItem.Id = 0; // Maintain modified and published dates as these will be reset by the Create Handlers var modifiedUtc = contentItem.ModifiedUtc; var publishedUtc = contentItem.PublishedUtc; var owner = contentItem.Owner; var author = contentItem.Author; if (String.IsNullOrEmpty(contentItem.ContentItemVersionId)) { contentItem.ContentItemVersionId = _idGenerator.GenerateUniqueId(contentItem); } // Remove previous latest item or they will continue to be listed as latest. // When importing a new draft the existing latest must be set to false. The creating version wins. if (contentItem.Latest && !contentItem.Published) { await RemoveLatestVersionAsync(contentItem, evictionVersions); } else if (contentItem.Published) { // When importing a published item existing drafts and existing published must be removed. // Otherwise an existing draft would become an orphan and if published would overwrite // the imported (which we assume is the version that wins) content. await RemoveVersionsAsync(contentItem, evictionVersions); } // When neither published or latest the operation will create a database record // which will be part of the content item archive. // Invoked create handlers. var context = new CreateContentContext(contentItem); await Handlers.InvokeAsync((handler, context) => handler.CreatingAsync(context), context, _logger); // The content item should be placed in the session store so that further calls // to ContentManager.Get by a scoped index provider will resolve the imported item correctly. _session.Save(contentItem); _contentManagerSession.Store(contentItem); await ReversedHandlers.InvokeAsync((handler, context) => handler.CreatedAsync(context), context, _logger); await UpdateAsync(contentItem); var result = await ValidateAsync(contentItem); if (!result.Succeeded) { return(result); } if (contentItem.Published) { // Invoke published handlers to add information to persistent stores var publishContext = new PublishContentContext(contentItem, null); await Handlers.InvokeAsync((handler, context) => handler.PublishingAsync(context), publishContext, _logger); await ReversedHandlers.InvokeAsync((handler, context) => handler.PublishedAsync(context), publishContext, _logger); } else { await SaveDraftAsync(contentItem); } // Restore values that may have been altered by handlers. if (modifiedUtc.HasValue) { contentItem.ModifiedUtc = modifiedUtc; } if (publishedUtc.HasValue) { contentItem.PublishedUtc = publishedUtc; } // There is a risk here that the owner or author does not exist in the importing system. // We check that at least a value has been supplied, if not the owner property and author // property would be left as the user who has run this import. if (!String.IsNullOrEmpty(owner)) { contentItem.Owner = owner; } if (!String.IsNullOrEmpty(author)) { contentItem.Author = author; } return(result); }
protected override void Creating(CreateContentContext context) { base.Creating(context); }
public virtual void Created(CreateContentContext context, TPart instance) { }
public virtual void Created(CreateContentContext context) {}
protected virtual void Created(CreateContentContext context, TPart instance) { }