public virtual Item GetSitecoreItem(ID itemId, Language language, Version version) { Assert.ArgumentNotNull(itemId, "itemId"); Assert.ArgumentNotNull(language, "language"); Assert.ArgumentNotNull(version, "version"); if (!this.FakeItems.ContainsKey(itemId)) { return(null); } // TODO:[High] Avoid the templates resetting. Required to avoid sharing templates between unit tests. this.Database.Engines.TemplateEngine.Reset(); var fakeItem = this.FakeItems[itemId]; if (version == Version.Latest) { version = Version.Parse(fakeItem.GetVersionCount(language.Name)); if (version == Version.Latest) { version = Version.First; } } var fields = this.BuildItemFieldList(fakeItem, fakeItem.TemplateID, language, version); return(ItemHelper.CreateInstance(this.database, fakeItem.Name, fakeItem.ID, fakeItem.TemplateID, fakeItem.BranchId, fields, language, version)); }
/// <summary> /// Gets an <see cref="Item"/> by path, language and version number. /// </summary> /// <param name="path">The item path.</param> /// <param name="language">The item language.</param> /// <param name="version">The item version.</param> /// <returns>The item.</returns> public Item GetItem(string path, string language, int version) { Assert.ArgumentNotNullOrEmpty(path, "path"); Assert.ArgumentNotNull(language, "language"); return(this.Database.GetItem(path, Language.Parse(language), Version.Parse(version))); }
public void ShouldGetItemByUri() { // arrange using (var db = new Db { new DbItem("home", this.itemId) { new DbField("Title") { { "en", 1, "Welcome!" }, { "da", 1, "Hello!" }, { "da", 2, "Velkommen!" } } } }) { // act & assert var uriEn1 = new ItemUri(this.itemId, Language.Parse("en"), Version.Parse(1), db.Database); Database.GetItem(uriEn1)["Title"].Should().Be("Welcome!"); var uriDa1 = new ItemUri(this.itemId, Language.Parse("da"), Version.Parse(1), db.Database); Database.GetItem(uriDa1)["Title"].Should().Be("Hello!"); var uriDa2 = new ItemUri(this.itemId, Language.Parse("da"), Version.Parse(2), db.Database); Database.GetItem(uriDa2)["Title"].Should().Be("Velkommen!"); } }
public void IsDerived_ItemIsOfGivenTemplate_ReturnsTrue() { // setup #region Setup var baseTemplateId = ID.NewID; var itemId = ID.NewID; var item = Substitute.For <Item>( itemId, new ItemData( new ItemDefinition(itemId, "Item Of Template", baseTemplateId, ID.NewID), this.Language, Version.Parse(1), new FieldList() ), this.Database); var template = new Template.Builder("Base Template", baseTemplateId, new TemplateCollection()).Template; this.TemplateManager.GetTemplate(baseTemplateId, this.Database).Returns(template); this.TemplateManager.GetTemplate(item).Returns(template); #endregion // act var isDerived = this.ItemExtensions.IsDerived(item, baseTemplateId); // assert isDerived.Should().BeTrue(); }
public void FakeDataUri_WhenCalledWithParams_SetsLanguage(ID id, int versionNumber) { var language = Language.Invariant; var version = Version.Parse(versionNumber); var uri = FakeUtil.FakeDataUri(id, language, version); uri.Language.Should().Be(language); }
public void FakeDataUri_WhenCalledWithParams_NeverReturnsNull(ID id, int versionNumber) { var language = Language.Invariant; var version = Version.Parse(versionNumber); var uri = FakeUtil.FakeDataUri(id, language, version); uri.Should().NotBeNull(); }
public override VersionUriList GetItemVersions(ItemDefinition itemDefinition, CallContext context) { if (Items.ContainsKey(itemDefinition.ID)) { VersionUriList versionUriList = new VersionUriList(); versionUriList.Add(LanguageManager.DefaultLanguage, Version.Parse(1)); return(versionUriList); } return(null); }
public void CreatesItemData() { IFixture fixture = new Fixture().Customize(new AutoSitecoreCustomization()); var data = fixture.Create <ItemData>(); data.Should().NotBeNull(); data.Language.Should().Be(Language.Invariant); data.Version.Should().Be(Version.Parse(0)); }
private static Item GetCurrentItem() { string queryString = WebUtil.GetQueryString("db"); string path = WebUtil.GetQueryString("id"); Language language = Language.Parse(WebUtil.GetQueryString("la")); Version version = Version.Parse(WebUtil.GetQueryString("vs")); Database database = Factory.GetDatabase(queryString); Assert.IsNotNull(database, queryString); return(database.GetItem(path, language, version)); }
public void FakeItemUri_WhenCalledWithItem_SetsDatabaseName(string itemName, ID itemId, int versionNumber, string databaseName) { var database = FakeUtil.FakeDatabase(databaseName); var item = FakeUtil.FakeItem(itemId, itemName, database); FakeUtil.FakeItemLanguage(item); var version = Version.Parse(versionNumber); item.Version.Returns(version); var uri = FakeUtil.FakeItemUri(item).Uri; uri.DatabaseName.Should().Be(databaseName); }
public void AddVersionAddsNewVersionAndReturnsNewVersionNumber( [Greedy] FakeDataProvider sut, ItemDefinition itemDefinition, Language language, int version, DbItem item) { sut.DataStorage.GetFakeItem(itemDefinition.ID).Returns(item); var baseVersion = new VersionUri(language, Version.Parse(version)); var expectedVersion = version + 1; var result = sut.AddVersion(itemDefinition, baseVersion, null); result.Should().Be(expectedVersion); item.GetVersionCount(language.Name).Should().Be(expectedVersion); }
public override VersionUriList GetItemVersions(ItemDefinition itemDefinition, CallContext context) { var versions = new VersionUriList(); if (itemDefinition == ItemDefinition.Empty) { return(versions); } var database = GetDatabase(context); var syncItem = database.GetItem(itemDefinition.ID.ToString()); foreach (var syncVersion in syncItem.Versions) { versions.Add(Language.Parse(syncVersion.Language), Version.Parse(syncVersion.Version)); } return(versions); }
public override VersionUriList GetItemVersions(ItemDefinition itemDefinition, CallContext context) { Assert.ArgumentNotNull(itemDefinition, "itemDefinition"); if (itemDefinition == ItemDefinition.Empty) { return(null); } var versions = new VersionUriList(); var syncItem = SerializedDatabase.GetItem(itemDefinition.ID); foreach (var syncVersion in syncItem.Versions) { versions.Add(Language.Parse(syncVersion.Language), Version.Parse(syncVersion.Version)); } return(versions); }
public void Setup() { this.ItemExtensions = Substitute.For <IItemExtensionsService>(); this.Database = Substitute.For <Database>(); this.Language = Substitute.For <Language>(); this.MetadataService = new MetadataService(this.ItemExtensions); var pageItemId = ID.NewID; this.MetadataItem = Substitute.For <Item>( pageItemId, new ItemData( new ItemDefinition(pageItemId, "Page Item", Templates.Metadata.TemplateId, ID.NewID), this.Language, Version.Parse(1), new FieldList() ), this.Database); this.MetadataItem[Templates.Metadata.FieldNames.MetaTitle].Returns("Page Meta Title"); //var field = Substitute.For<Field>(); //field.Value.Returns("Page Meta Title"); //this.MetadataItem.Fields[Templates.Metadata.FieldNames.MetaTitle].Returns(field); this.MetadataItem[Templates.Metadata.FieldNames.MetaDescription].Returns("Page Meta Description"); this.MetadataItem[Templates.Metadata.FieldNames.MetaKeywords].Returns("Page Meta Keywords"); var rootItemId = ID.NewID; this.WebsiteMetadataItem = Substitute.For <Item>( rootItemId, new ItemData( new ItemDefinition(rootItemId, "Website Metadata", Templates.WebsiteMetadata.TemplateId, ID.NewID), this.Language, Version.Parse(1), new FieldList() ), this.Database); this.WebsiteMetadataItem[Templates.WebsiteMetadata.FieldNames.MetaTitle].Returns("Site Meta Title"); }
public override VersionUriList GetItemVersions(ItemDefinition itemDefinition, CallContext context) { var list = new List <VersionUri>(); var versions = new VersionUriList(); var item = this.DataStorage.GetFakeItem(itemDefinition.ID); if (item == null) { return(versions); } foreach (var field in item.Fields) { foreach (var fieldLang in field.Values) { var language = fieldLang.Key; foreach (var fieldVer in fieldLang.Value) { var version = fieldVer.Key; if (list.Any(l => l.Language.Name == language && l.Version.Number == version)) { continue; } list.Add(new VersionUri(Language.Parse(language), Version.Parse(version))); } } } foreach (var version in list) { versions.Add(version); } return(versions); }
public void IsDerived_ItemInheritsBaseTemplate_ReturnsTrue() { // setup #region Setup var itemTemplateId = ID.NewID; var baseTemplateId = ID.NewID; var itemId = ID.NewID; var item = Substitute.For <Item>( itemId, new ItemData( new ItemDefinition(itemId, "Item Of Base Template", itemTemplateId, ID.Null), this.Language, Version.Parse(1), new FieldList() ), this.Database); var baseTemplate = new Template.Builder("Base Template", baseTemplateId, this.TemplateEngine).Template; var itemTemplateItem = new Template.Builder("Item Template", itemTemplateId, this.TemplateEngine); itemTemplateItem.SetBaseIDs(baseTemplateId.ToString()); var itemTemplate = itemTemplateItem.Template; this.TemplateEngine.GetTemplate(itemTemplateId).Returns(itemTemplate); this.TemplateEngine.GetTemplate(baseTemplateId).Returns(baseTemplate); this.TemplateManager.GetTemplate(itemTemplateId, this.Database).Returns(itemTemplate); this.TemplateManager.GetTemplate(baseTemplateId, this.Database).Returns(baseTemplate); this.TemplateManager.GetTemplate(item).Returns(itemTemplate); #endregion // act var isDerived = this.ItemExtensions.IsDerived(item, baseTemplateId); // assert isDerived.Should().BeTrue(); }
public void ShouldGetNewItemVersion(AddVersionCommand sut, ID itemId) { // arrange var dbitem = new DbItem("home") { { "Title", "Hello!" } }; sut.DataStorage.GetFakeItem(itemId).Returns(dbitem); var originalItem = ItemHelper.CreateInstance(itemId); var itemWithNewVersion = ItemHelper.CreateInstance(itemId); sut.DataStorage.GetSitecoreItem(itemId, Language.Parse("en"), Version.Parse(2)).Returns(itemWithNewVersion); sut.Initialize(originalItem); // act var result = ReflectionUtil.CallMethod(sut, "DoExecute"); // assert result.Should().BeSameAs(itemWithNewVersion); }
protected void Run(ClientPipelineArgs args) { Assert.ArgumentNotNull(args, "args"); string dbName = args.Parameters["databasename"]; string id = args.Parameters["id"]; string lang = args.Parameters["language"]; string ver = args.Parameters["version"]; Database database = Factory.GetDatabase(dbName); Assert.IsNotNull(database, dbName); Item obj = database.Items[id, Language.Parse(lang), Version.Parse(ver)]; if (obj == null) { SheerResponse.Alert("Item not found."); } else { if (!SheerResponse.CheckModified()) { return; } if (args.IsPostBack) { return; } UrlString urlString = new UrlString(UIUtil.GetUri("control:SchedulePublish")); urlString.Append("id", obj.ID.ToString()); urlString.Append("unpublish", args.Parameters["unpublish"]); SheerResponse.ShowModalDialog(urlString.ToString(), "600", "600", string.Empty, true); args.WaitForPostBack(); } }
// Methods public void Comment(ClientPipelineArgs args) { if (!args.IsPostBack) { Context.ClientPage.ClientResponse.Input("Enter a comment:", string.Empty); args.WaitForPostBack(); } else if (args.Result.Length > 0x7d0) { Context.ClientPage.ClientResponse.ShowError(new Exception(string.Format("The comment is too long.\n\nYou have entered {0} characters.\nA comment cannot contain more than 2000 characters.", args.Result.Length))); Context.ClientPage.ClientResponse.Input("Enter a comment:", string.Empty); args.WaitForPostBack(); } else if (((args.Result != null) && (args.Result != "null")) && (args.Result != "undefined")) { IWorkflowProvider workflowProvider = Context.ContentDatabase.WorkflowProvider; if (workflowProvider != null) { IWorkflow workflow = workflowProvider.GetWorkflow(Context.ClientPage.ServerProperties["workflowid"] as string); if (workflow != null) { Item item = Context.ContentDatabase.Items[Context.ClientPage.ServerProperties["id"] as string, Language.Parse(Context.ClientPage.ServerProperties["language"] as string), Version.Parse(Context.ClientPage.ServerProperties["version"] as string)]; if (item != null) { try { workflow.Execute(Context.ClientPage.ServerProperties["command"] as string, item, args.Result, true, new object[0]); } catch (WorkflowStateMissingException) { SheerResponse.Alert("One or more items could not be processed because their workflow state does not specify the next step.", new string[0]); } Context.ClientPage.ClientResponse.SetLocation(string.Empty); } } } } }
public void FiltersOnPathAndTemplate() { // Mock the database var db = Mock.Of <Database>(); // Mock the parent item var parentId = ID.NewID; var parentDef = new ItemDefinition(parentId, "parent", Templates.Product.Id, ID.Null); var parentData = new ItemData(parentDef, Language.Parse("en"), Version.Parse(1), new FieldList()); var parent = new Mock <Item>(parentId, parentData, db); // Mock the Sitecore services var factoryMock = new Mock <BaseFactory>(); factoryMock.Setup(x => x.GetDatabase(It.IsAny <string>())).Returns(db); var factory = factoryMock.Object; var itemManager = Mock.Of <BaseItemManager>(); // Mock search context, so we are testing LINQ to Objects instead of LINQ to Sitecore var itemUri = new ItemUri("sitecore://master/{11111111-1111-1111-1111-111111111111}?lang=en&ver=1"); var mockSearchContext = new Mock <IProviderSearchContext>(); mockSearchContext.Setup(x => x.GetQueryable <ProductSearchQuery>()) .Returns(new[] { // Matches Path and Template new ProductSearchQuery { UniqueId = itemUri, Templates = new[] { Templates.Product.Id }, Paths = new[] { parentId } }, // Matches Path and Template new ProductSearchQuery { UniqueId = itemUri, Templates = new[] { ID.NewID, Templates.Product.Id, ID.NewID }, Paths = new[] { ID.NewID, parentId, ID.NewID } }, // Matches Template Only new ProductSearchQuery { UniqueId = itemUri, Templates = new[] { Templates.Product.Id }, Paths = new[] { ID.NewID } }, // Matches Path Only new ProductSearchQuery { UniqueId = itemUri, Templates = new[] { ID.NewID }, Paths = new[] { parentId } } }.AsQueryable()); // Use Moq.Protected to ensure our test object uses the mock search context var mockRepo = new Mock <ProductRepository>(factory, itemManager); mockRepo.Protected() .Setup <IProviderSearchContext>("GetSearchContext", ItExpr.IsAny <Item>()) .Returns(mockSearchContext.Object); // Act var result = mockRepo.Object.GetProducts(parent.Object).ToList(); // If the tested class is filtering appropriately, we should get predictible results Assert.Equal(2, result.Count); }
public SkinnyItem(string id, string language, string version, string databaseName) : this(new ItemUri(ID.Parse(id), SCLang.Parse(language), SCVersion.Parse(version), databaseName)) { }
public void ShouldNotUpdateFieldsIfItemVersionIsZero(SaveItemCommand sut, DbItem item, FieldList fields, Language language) { // arrange sut.DataStorage.GetFakeItem(item.ID).Returns(item); var updatedItem = ItemHelper.CreateInstance(sut.Database, "updated item", item.ID, ID.NewID, ID.Null, fields, language, Version.Parse(0)); sut.Initialize(updatedItem); // act Action action = () => ReflectionUtil.CallMethod(sut, "DoExecute"); // assert action.ShouldNotThrow(); }
public void ShouldCreateVersionedItem() { using (var db = new Db { new DbItem("home") { Fields = { new DbField("Title") { { "en", 1, "title version 1" }, { "en", 2, "title version 2" } } } } }) { var item1 = db.Database.GetItem("/sitecore/content/home", Language.Parse("en"), Version.Parse(1)); item1["Title"].Should().Be("title version 1"); item1.Version.Number.Should().Be(1); var item2 = db.Database.GetItem("/sitecore/content/home", Language.Parse("en"), Version.Parse(2)); item2["Title"].Should().Be("title version 2"); item2.Version.Number.Should().Be(2); } }
public void ShouldUpdateBranchId(SaveItemCommand sut, DbItem item, ID branchId, FieldList fields, Language language) { // arrange sut.DataStorage.GetFakeItem(item.ID).Returns(item); var updatedItem = ItemHelper.CreateInstance(sut.Database, "updated item", item.ID, ID.NewID, branchId, fields, language, Version.Parse(0)); sut.Initialize(updatedItem); // act ReflectionUtil.CallMethod(sut, "DoExecute"); // assert item.BranchId.Should().Be(branchId); }
public void BuildDiff(string server) { Compare = new Dictionary <string, List <Tuple <string, string> > >(); IItemData itemData = null; itemData = Bootstrap.Container.Resolve <IRemoteContentService>().GetRemoteItemData(Guid.Parse(Id), server); using (new SecurityDisabler()) { var localItem = Factory.GetDatabase("master", true).DataManager.DataEngine.GetItem(new ID(Id), LanguageManager.DefaultLanguage, Sitecore.Data.Version.Latest); localItem.Fields.ReadAll(); foreach (var chk in itemData.SharedFields) { if (AreFieldsEqual(localItem.Fields[new ID(chk.FieldId)], chk)) { continue; } if (!Compare.ContainsKey("shared")) { Compare["shared"] = new List <Tuple <string, string> >(); } Compare["shared"].Add(chk.BlobId != null ? new Tuple <string, string>(chk.NameHint, "Blob value changed") : new Tuple <string, string>(chk.NameHint, HtmlDiff.HtmlDiff.Execute(HttpUtility.HtmlEncode(localItem[new ID(chk.FieldId)].Replace("\r", "")), HttpUtility.HtmlEncode(chk.Value.Replace("\r", ""))))); } Dictionary <string, int> tracker = new Dictionary <string, int>(); foreach (var ver in itemData.Versions) { if (!tracker.ContainsKey(LanguageManager.GetLanguage(ver.Language.Name).Name)) { tracker.Add(LanguageManager.GetLanguage(ver.Language.Name).Name, 1); } else { tracker[LanguageManager.GetLanguage(ver.Language.Name).Name]++; } Item verItem = localItem.Database.DataManager.DataEngine.GetItem(new ID(Id), LanguageManager.GetLanguage(ver.Language.Name), Version.Parse(ver.VersionNumber)); verItem.Fields.ReadAll(); HashSet <Guid> fieldsProcessed = new HashSet <Guid>(ver.Fields.Select(x => x.FieldId)); foreach (var verfield in ver.Fields) { if (AreFieldsEqual(verItem.Fields[new ID(verfield.FieldId)], verfield)) { continue; } string key = ver.Language.Name + " v" + ver.VersionNumber; if (!Compare.ContainsKey(key)) { Compare[key] = new List <Tuple <string, string> >(); } Compare[key].Add(verfield.BlobId != null ? new Tuple <string, string>(verfield.NameHint, "Blob value changed") : new Tuple <string, string>(verfield.NameHint, HtmlDiff.HtmlDiff.Execute(HttpUtility.HtmlEncode(verItem[new ID(verfield.FieldId)].Replace("\r", "")), HttpUtility.HtmlEncode(verfield.Value.Replace("\r", ""))))); } foreach (Field field in verItem.Fields.Where(x => !x.Unversioned && !x.Shared).Where(x => !fieldsProcessed.Contains(x.ID.Guid) && !string.IsNullOrWhiteSpace(x.Value))) { string key = ver.Language.Name + " v" + ver.VersionNumber; if (!Compare.ContainsKey(key)) { Compare[key] = new List <Tuple <string, string> >(); } Compare[key].Add(field.HasBlobStream ? new Tuple <string, string>(field.DisplayName, "Blob value changed") : new Tuple <string, string>(field.DisplayName, HtmlDiff.HtmlDiff.Execute(HttpUtility.HtmlEncode(verItem[field.ID].Replace("\r", "")), ""))); } } foreach (var lang in localItem.Languages.Where(x => !tracker.ContainsKey(x.Name))) { Item langItem = localItem.Database.DataManager.DataEngine.GetItem(new ID(Id), lang, Version.Latest); langItem.Fields.ReadAll(); for (int ver = 1; ver <= langItem.Versions.Count; ver++) { string key = "Extra version"; if (!Compare.ContainsKey(key)) { Compare[key] = new List <Tuple <string, string> >(); } Compare[key].Add(new Tuple <string, string>("Extra local version exists that's not on the remote.", $"{lang.Name} v{ver}")); } } foreach (var lang in localItem.Languages.Where(x => tracker.ContainsKey(x.Name))) { Item langItem = localItem.Database.DataManager.DataEngine.GetItem(new ID(Id), lang, Version.Latest); langItem.Fields.ReadAll(); for (int ver = tracker[lang.Name] + 1; ver <= langItem.Versions.Count; ver++) { string key = "Extra version"; if (!Compare.ContainsKey(key)) { Compare[key] = new List <Tuple <string, string> >(); } Compare[key].Add(new Tuple <string, string>("Extra local version exists that's not on the remote.", $"{lang.Name} v{ver}")); } } foreach (var unver in itemData.UnversionedFields) { Item verItem = localItem.Database.DataManager.DataEngine.GetItem(new ID(Id), LanguageManager.GetLanguage(unver.Language.Name), Version.Latest); verItem.Fields.ReadAll(); foreach (var unverfield in unver.Fields) { if (AreFieldsEqual(verItem.Fields[new ID(unverfield.FieldId)], unverfield)) { continue; } if (!Compare.ContainsKey(unver.Language.Name)) { Compare[verItem.Language.Name] = new List <Tuple <string, string> >(); } Compare[unver.Language.Name].Add(unverfield.BlobId != null ? new Tuple <string, string>(unverfield.NameHint, "Blob value changed") : new Tuple <string, string>(unverfield.NameHint, HtmlDiff.HtmlDiff.Execute(HttpUtility.HtmlEncode(verItem[new ID(unverfield.FieldId)].Replace("\r", "")), HttpUtility.HtmlEncode(unverfield.Value.Replace("\r", ""))))); } } } }
public override void HandleMessage(Message message) { switch (message.Name) { case "workflow:send": this.Send(message); return; case "workflow:sendselected": this.SendSelected(message); return; case "workflow:sendall": this.SendAll(message); return; case "window:close": Windows.Close(); return; case "workflow:showhistory": ShowHistory(message, Context.ClientPage.ClientRequest.Control); return; case "workbox:hide": Context.ClientPage.SendMessage(this, "pane:hide(id=" + message["id"] + ")"); Context.ClientPage.ClientResponse.SetAttribute("Check_Check_" + message["id"], "checked", "false"); break; case "pane:hidden": Context.ClientPage.ClientResponse.SetAttribute("Check_Check_" + message["paneid"], "checked", "false"); break; case "workbox:show": Context.ClientPage.SendMessage(this, "pane:show(id=" + message["id"] + ")"); Context.ClientPage.ClientResponse.SetAttribute("Check_Check_" + message["id"], "checked", "true"); break; case "pane:showed": Context.ClientPage.ClientResponse.SetAttribute("Check_Check_" + message["paneid"], "checked", "true"); break; } base.HandleMessage(message); string str = message["id"]; if ((str != null) && (str.Length > 0)) { string name = StringUtil.GetString(new string[] { message["language"] }); string str3 = StringUtil.GetString(new string[] { message["version"] }); Item item = Context.ContentDatabase.Items[str, Language.Parse(name), Version.Parse(str3)]; if (item != null) { Dispatcher.Dispatch(message, item); } } }
protected virtual Item PasteVersion(Item item, IItemVersion serializedVersion, bool creatingNewItem, List <TemplateMissingFieldException> softErrors) { Language language = Language.Parse(serializedVersion.Language.Name); var targetVersion = Version.Parse(serializedVersion.VersionNumber); Item languageItem = item.Database.GetItem(item.ID, language); if (languageItem == null) { throw new InvalidOperationException("Item retrieved from the database was null. This may indicate issues with the Sitecore cache. Recycle your app pool and try again and it should work."); } Item languageVersionItem = languageItem.Versions[targetVersion]; IDictionary <Guid, IItemFieldValue> serializedVersionFieldsLookup = serializedVersion.Fields.ToDictionary(field => field.FieldId); // Add a new version if we need to for the serialized version we're pasting // NOTE: normally Sitecore will return an empty version when requested (e.g. you can ask for 'en#25' and get a blank version back) // so this null check is only here for legacy support if (languageVersionItem == null) { languageVersionItem = languageItem.Versions.AddVersion(); if (languageVersionItem == null) { throw new InvalidOperationException("Failed to add a new version: AddVersion() returned null."); } if (!creatingNewItem) { _logger.AddedNewVersion(languageVersionItem); } } // Based on the note above, in order to detect the modern form where item.Versions[] returns a blank version no matter what, // we need to check again to see if the version we requested is actually currently present on the item or not, so we can correctly log version adds // ReSharper disable once SimplifyLinqExpression if (!languageVersionItem.Versions.GetVersionNumbers().Any(x => x.Number == languageVersionItem.Version.Number)) { if (!creatingNewItem) { _logger.AddedNewVersion(languageVersionItem); } } // begin writing the version data bool commitEdit = false; try { languageVersionItem.Editing.BeginEdit(); languageVersionItem.RuntimeSettings.ReadOnlyStatistics = true; if (languageVersionItem.Versions.Count == 0) { languageVersionItem.Fields.ReadAll(); } // find versioned fields that need to be reset to standard value, because they are not in serialized // (we do all these checks so we can back out of the edit context and avoid a DB write if we don't need one) foreach (Field field in languageVersionItem.Fields) { // if the field is excluded by the fieldFilter if (!_fieldFilter.Includes(field.ID.Guid)) { continue; } // shared/unversioned fields = ignore, those are handled in their own paste methods if (field.Shared || field.Unversioned) { continue; } // if we have a value in the serialized item, we don't need to reset the field if (serializedVersionFieldsLookup.ContainsKey(field.ID.Guid)) { continue; } // if the field is one of revision, updated, or updated by we can specially ignore it, because these will get set below if actual field changes occur // so there's no need to reset them as well if (field.ID == FieldIDs.Revision || field.ID == FieldIDs.UpdatedBy || field.ID == FieldIDs.Updated) { continue; } _logger.ResetFieldThatDidNotExistInSerialized(field); field.Reset(); commitEdit = true; } bool wasOwnerFieldParsed = false; foreach (IItemFieldValue field in serializedVersion.Fields) { if (field.FieldId == FieldIDs.Owner.Guid) { wasOwnerFieldParsed = true; } try { if (PasteField(languageVersionItem, field, creatingNewItem)) { commitEdit = true; } } catch (TemplateMissingFieldException tex) { softErrors.Add(tex); } } if (!wasOwnerFieldParsed) { languageVersionItem.Fields[FieldIDs.Owner].Reset(); commitEdit = true; } // if the item came with blank statistics, and we're creating the item or have version updates already, let's set some sane defaults - update revision, set last updated, etc if (creatingNewItem || commitEdit) { if (!serializedVersionFieldsLookup.ContainsKey(FieldIDs.Revision.Guid)) { languageVersionItem.Fields[FieldIDs.Revision].SetValue(Guid.NewGuid().ToString(), true); } if (!serializedVersionFieldsLookup.ContainsKey(FieldIDs.Updated.Guid)) { languageVersionItem[FieldIDs.Updated] = DateUtil.ToIsoDate(DateTime.UtcNow); } if (!serializedVersionFieldsLookup.ContainsKey(FieldIDs.UpdatedBy.Guid)) { languageVersionItem[FieldIDs.UpdatedBy] = @"sitecore\unicorn"; } } // we commit the edit context - and write to the DB - only if we changed something if (commitEdit) { languageVersionItem.Editing.EndEdit(); } } finally { if (languageVersionItem.Editing.IsEditing) { languageVersionItem.Editing.CancelEdit(); } } if (commitEdit) { ClearCaches(languageVersionItem.Database, languageVersionItem.ID); ResetTemplateEngineIfItemIsTemplate(languageVersionItem); } return(languageVersionItem); }
private void Send(Message message) { IWorkflowProvider workflowProvider = Context.ContentDatabase.WorkflowProvider; if (workflowProvider != null) { string workflowID = message["wf"]; IWorkflow workflow = workflowProvider.GetWorkflow(workflowID); if (workflow != null) { Item item = Context.ContentDatabase.Items[message["id"], Language.Parse(message["la"]), Version.Parse(message["vs"])]; if (item != null) { if ((message["ui"] != "1") && !(message["suppresscomment"] == "1")) { Context.ClientPage.ServerProperties["id"] = message["id"]; Context.ClientPage.ServerProperties["language"] = message["la"]; Context.ClientPage.ServerProperties["version"] = message["vs"]; Context.ClientPage.ServerProperties["command"] = message["command"]; Context.ClientPage.ServerProperties["workflowid"] = workflowID; Context.ClientPage.Start(this, "Comment"); } else { try { workflow.Execute(message["command"], item, string.Empty, true, new object[0]); } catch (WorkflowStateMissingException) { SheerResponse.Alert("One or more items could not be processed because their workflow state does not specify the next step.", new string[0]); } Context.ClientPage.ClientResponse.SetLocation(string.Empty); } } } } }
private void SendSelected(Message message) { IWorkflowProvider workflowProvider = Context.ContentDatabase.WorkflowProvider; if (workflowProvider != null) { string workflowID = message["wf"]; string str2 = message["ws"]; IWorkflow workflow = workflowProvider.GetWorkflow(workflowID); if (workflow != null) { int num = 0; bool flag = false; foreach (string str3 in Context.ClientPage.ClientRequest.Form.Keys) { if ((str3 != null) && str3.StartsWith("check_")) { string str4 = "hidden_" + str3.Substring(6); string[] strArray = Context.ClientPage.ClientRequest.Form[str4].Split(new char[] { ',' }); Item item = Context.ContentDatabase.Items[strArray[0], Language.Parse(strArray[1]), Version.Parse(strArray[2])]; if (item != null) { WorkflowState state = workflow.GetState(item); if (state.StateID == str2) { try { workflow.Execute(message["command"], item, state.DisplayName, true, new object[0]); } catch (WorkflowStateMissingException) { flag = true; } num++; } } } } if (flag) { SheerResponse.Alert("One or more items could not be processed because their workflow state does not specify the next step.", new string[0]); } if (num == 0) { Context.ClientPage.ClientResponse.Alert("There are no selected items."); } else { Context.ClientPage.ClientResponse.SetLocation(string.Empty); } } } }
/// <summary> /// Gets an <see cref="Item"/> by id, language and version number. /// </summary> /// <param name="id">The item id.</param> /// <param name="language">The item language.</param> /// <param name="version">The item version.</param> /// <returns>The item.</returns> public Item GetItem(ID id, string language, int version) { Assert.ArgumentNotNullOrEmpty(language, "language"); return(this.Database.GetItem(id, Language.Parse(language), Version.Parse(version))); }