public void Process(SC.Pipelines.GetContentEditorWarnings.GetContentEditorWarningsArgs args) { Assert.ArgumentNotNull(args, "args"); SC.Data.Items.Item item = args.Item; if (item == null) { return; } if (SC.Context.IsAdministrator || CheckIn.CanCheckIn(item)) { if (item.Locking.IsLocked() && (string.Compare(item.Locking.GetOwner(), SC.Context.User.Name, StringComparison.InvariantCultureIgnoreCase) != 0)) { SC.Pipelines.GetContentEditorWarnings.GetContentEditorWarningsArgs.ContentEditorWarning warning = args.Add(); warning.Title = SC.Globalization.Translate.Text("'{0}' has locked this item.", new object[] { item.Locking.GetOwnerWithoutDomain() }); warning.AddOption(SC.Globalization.Translate.Text("Check In"), string.Format("item:checkin(id={0},language={1},version={2})", item.ID, item.Language, item.Version.Number)); } } else if (item.Locking.IsLocked()) { if (!item.Locking.HasLock()) { args.Add(SC.Globalization.Translate.Text("You cannot edit this item because '{0}' has locked it.", new object[] { item.Locking.GetOwnerWithoutDomain() }), string.Empty); } } else if (SC.Configuration.Settings.RequireLockBeforeEditing && SC.Data.Managers.TemplateManager.IsFieldPartOfTemplate(SC.FieldIDs.Lock, item)) { SC.Pipelines.GetContentEditorWarnings.GetContentEditorWarningsArgs.ContentEditorWarning warning = args.Add(); warning.Title = SC.Globalization.Translate.Text("You must lock this item before you can edit it."); warning.Text = SC.Globalization.Translate.Text("To lock this item, click Edit on the Home tab."); warning.AddOption(SC.Globalization.Translate.Text("Lock and Edit"), "item:checkout"); } }
public override SC.Shell.Framework.Commands.CommandState QueryState(SC.Shell.Framework.Commands.CommandContext context) { Assert.ArgumentNotNull(context, "context"); if (context.Items.Length != 1) { return(base.QueryState(context)); } SC.Data.Items.Item item = context.Items[0]; Assert.ArgumentNotNull(item, "context.Items[0]"); if (SC.Context.IsAdministrator || !CheckIn.CanCheckIn(item)) { return(base.QueryState(context)); } if (!item.Locking.IsLocked()) { return(SC.Shell.Framework.Commands.CommandState.Hidden); } if (CanCheckIn(item)) { return(SC.Shell.Framework.Commands.CommandState.Enabled); } return(base.QueryState(context)); }
/// <summary> /// Triggered at interval to determine whether to rebuild the index. /// </summary> /// <param name="args">Event arguments (not used by this implementation)</param> internal void Handle(EventArgs args) { Assert.IsNotNull(this._index, "_index"); string path = "/sitecore/system/Settings/Rules/Indexing/Rebuilding/Rules"; using (new SC.SecurityModel.SecurityDisabler()) { SC.Data.Items.Item ruleRoot = this._ruleDatabase.GetItem(path); SC.Diagnostics.Assert.IsNotNull( ruleRoot, string.Format("ruleRoot item {0} in database {1}", path, this._ruleDatabase.Name)); SC.Sharedsource.Rules.Indexing.IndexRebuildingRuleContext ruleContext = new SC.Sharedsource.Rules.Indexing.IndexRebuildingRuleContext(this._index) { IndexedDatabaseName = this._indexedDatabaseName, }; SC.Rules.RuleList <SC.Sharedsource.Rules.Indexing.IndexRebuildingRuleContext> ruleList = SC.Rules.RuleFactory.GetRules <SC.Sharedsource.Rules.Indexing.IndexRebuildingRuleContext>(ruleRoot.Axes.GetDescendants(), "Rule"); Assert.IsNotNull(ruleList, "ruleList"); Assert.IsTrue( ruleList.Count > 0, "ruleList.Count < 1 for " + path + " in database " + this._ruleDatabase.Name); ruleList.Run(ruleContext); if (ruleContext.ShouldRebuild) { SC.ContentSearch.Diagnostics.CrawlingLog.Log.Info( this + " : rebuild " + this._index.Name); this._index.Rebuild(); } } }
/// <summary> /// Triggered by Sitecore to initialize the index rebuilding strategy. /// </summary> /// <param name="index">Index associated with the index rebuilding strategy.</param> public void Initialize(SC.ContentSearch.ISearchIndex index) { Assert.ArgumentNotNull(index, "index"); if (this._ruleDatabase == null && !string.IsNullOrEmpty(index.Name)) { string[] parts = index.Name.Split('_'); if (parts.Length > 1) { this._ruleDatabase = SC.Configuration.Factory.GetDatabase(parts[1]); } } SC.Diagnostics.Assert.IsNotNull(this._ruleDatabase, "_ruleDatabase"); if (string.IsNullOrEmpty(this._indexedDatabaseName)) { this._indexedDatabaseName = this._ruleDatabase.Name; } SC.ContentSearch.Diagnostics.CrawlingLog.Log.Info(string.Format( "[Index={0}] Initializing {1} with interval '{2}'.", index.Name, this.GetType().Name, this._alarmClock.Interval)); this._index = index; this._alarmClock.Ring += (sender, args) => this.Handle(args); }
public static bool HasUnlockAccess(SC.Data.Items.Item item, SC.Security.Accounts.User user = null) { Assert.ArgumentNotNull(item, "item"); if (user == null) { user = SC.Context.User; Assert.IsNotNull(user, "context user"); } if (user.IsAdministrator) { return(true); } SC.Security.AccessControl.AccessRight checkIn = SC.Security.AccessControl.AccessRight.FromName("item:checkin"); if (checkIn != null) { return(SC.Security.AccessControl.AuthorizationManager.IsAllowed(item, checkIn, user)); } SC.Security.Accounts.Role control = SC.Security.Accounts.Role.FromName("sitecore\\Sitecore Client Maintaining"); return(SC.Security.Accounts.Role.Exists(control.Name) && SC.Security.Accounts.RolesInRolesManager.IsUserInRole(SC.Context.User, control, true /*includeIndirectMembership*/)); }
/// <summary> /// Apply the rule. /// </summary> /// <param name="ruleContext">Rule processing context.</param> public override void Apply(T ruleContext) { Assert.ArgumentNotNull(ruleContext, "ruleContext"); Assert.ArgumentNotNull(ruleContext.Item, "ruleContext.Item"); // for each language available in the item foreach (SC.Globalization.Language lang in ruleContext.Item.Languages) { SC.Data.Items.Item item = ruleContext.Item.Database.GetItem( ruleContext.Item.ID, lang); if (item == null) { continue; } // to prevent the while loop from reaching MinVersions, // only process this number of items int limit = item.Versions.Count - this.MinVersions; int i = 0; while (item.Versions.Count > this.MinVersions && i < limit) { SC.Data.Items.Item version = item.Versions.GetVersions()[i++]; Assert.IsNotNull(version, "version"); if (this.MinUpdatedDays < 1 || version.Statistics.Updated.AddDays(this.MinUpdatedDays) < DateTime.Now) { this.HandleVersion(version); } } } }
public ManagerResponse <CreateUserResult, CommerceUser> RegisterUserCustomer(IStorefrontContext storefrontContext, string userName, string password, string email, string secondaryEmail) { Assert.ArgumentNotNull(storefrontContext, nameof(storefrontContext)); Assert.ArgumentNotNullOrEmpty(userName, nameof(userName)); Assert.ArgumentNotNullOrEmpty(password, nameof(password)); CreateUserResult createUserResult1; try { var createUserRequest = new CreateUserRequest(userName, password, email, storefrontContext.CurrentStorefront.ShopName); createUserRequest.Properties.Add("SecondEmail", secondaryEmail); createUserResult1 = CustomerServiceProvider.CreateUser(createUserRequest); //createUserResult1 = CustomerServiceProvider.CreateUser(new CreateUserRequest(userName, password, email, storefrontContext.CurrentStorefront.ShopName)); if (!createUserResult1.Success) { Helpers.LogSystemMessages(createUserResult1.SystemMessages, createUserResult1); } else if (createUserResult1.Success) { if (createUserResult1.CommerceUser == null) { if (createUserResult1.SystemMessages.Count == 0) { createUserResult1.Success = false; createUserResult1.SystemMessages.Add(new SystemMessage() { Message = storefrontContext.GetSystemMessage("User Already Exists") }); } } } } catch (MembershipCreateUserException ex) { CreateUserResult createUserResult2 = new CreateUserResult { Success = false }; createUserResult1 = createUserResult2; createUserResult1.SystemMessages.Add(new SystemMessage() { Message = ErrorCodeToString(storefrontContext, ex.StatusCode) }); } catch (Exception ex) { CreateUserResult createUserResult2 = new CreateUserResult { Success = false }; createUserResult1 = createUserResult2; createUserResult1.SystemMessages.Add(new SystemMessage() { Message = storefrontContext.GetSystemMessage("Unknown Membership Provider Error") }); } CreateUserResult serviceProviderResult = createUserResult1; return(new ManagerResponse <CreateUserResult, CommerceUser>(serviceProviderResult, serviceProviderResult.CommerceUser)); }
public override void Process(ServicePipelineArgs args) { ValidateArguments <CreateUserRequest, CreateUserResult>(args, out var request, out var result); Assert.IsNotNull(request.UserName, "request.UserName"); Assert.IsNotNull(request.Password, "request.Password"); Container container = GetContainer(request.Shop.Name, string.Empty, "", "", args.Request.CurrencyCode, new DateTime?()); CommerceUser commerceUser1 = result.CommerceUser; if (commerceUser1 != null && commerceUser1.UserName.Equals(request.UserName, StringComparison.OrdinalIgnoreCase)) { string entityId = "Entity-Customer-" + request.UserName; ServiceProviderResult currentResult = new ServiceProviderResult(); EntityView entityView = GetEntityView(container, entityId, string.Empty, "Details", string.Empty, currentResult); if (currentResult.Success && !string.IsNullOrEmpty(entityView.EntityId)) { base.Process(args); return; } } EntityView entityView1 = GetEntityView(container, string.Empty, string.Empty, "Details", "AddCustomer", result); if (!result.Success) { return; } entityView1.Properties.FirstOrDefault(p => p.Name.Equals("Domain")).Value = request.UserName.Split('\\')[0]; entityView1.Properties.FirstOrDefault(p => p.Name.Equals("LoginName")).Value = request.UserName.Split('\\')[1]; entityView1.Properties.FirstOrDefault(p => p.Name.Equals("AccountStatus")).Value = "ActiveAccount"; if (!string.IsNullOrEmpty(request.Email)) { entityView1.Properties.FirstOrDefault(p => p.Name.Equals("Email")).Value = request.Email; } CommerceCommand commerceCommand = DoAction(container, entityView1, result); if (commerceCommand != null && commerceCommand.ResponseCode.Equals("ok", StringComparison.OrdinalIgnoreCase)) { CommerceUser commerceUser2 = EntityFactory.Create <CommerceUser>("CommerceUser"); commerceUser2.Email = request.Email; commerceUser2.UserName = request.UserName; commerceUser2.ExternalId = commerceCommand.Models.OfType <CustomerAdded>().FirstOrDefault()?.CustomerId; result.CommerceUser = commerceUser2; request.Properties.Add(new PropertyItem() { Key = "UserId", Value = result.CommerceUser.ExternalId }); string entityId = "Entity-Customer-" + request.UserName; TestSave(container, entityId, request, result, commerceUser2.ExternalId); } base.Process(args); }
/// <summary> /// Rules engine condition implementation to determine if the name of an index /// contains a specific value. /// </summary> /// <param name="ruleContext">Rules processing context.</param> /// <returns>Returns true if the name of the index contains the specified value.</returns> protected override bool Execute(T ruleContext) { Assert.ArgumentNotNull(ruleContext, "ruleContext"); Assert.ArgumentNotNull(ruleContext.IndexName, "ruleContext.IndexName)"); Assert.ArgumentNotNullOrEmpty(this.MatchIndexNameAgainst, "MatchIndexNameAgainst"); return(ruleContext.IndexName.ToLower().Contains( this.MatchIndexNameAgainst.ToLower())); }
/// <summary> /// Rules engine condition to determine whether the number of items updated /// since the last commit of changes to the search index to disk exceeds /// a given threshold. /// </summary> /// <param name="ruleContext">Rule processing context.</param> /// <returns>True if the number of indexed items updated since the last commit /// exceeds the given threshold.</returns> protected override bool Execute(T ruleContext) { Assert.IsTrue(this.Threshold > 0, "Threshold: " + this.Threshold); Assert.ArgumentNotNull(ruleContext, "ruleContext"); bool result = ruleContext.UpdatesSinceLastCommit > this.Threshold; return(result); }
/// <summary> /// Rules engine condition to determine whether a given number /// of milliseconds has elapsed since the last commit of changes /// to a search engine to disk. /// </summary> /// <param name="ruleContext">Rule context type.</param> /// <returns>True if the number of milliseconds has updates </returns> protected override bool Execute(T ruleContext) { Assert.IsTrue(this.Threshold > 0, "Threshold: " + this.Threshold); Assert.ArgumentNotNull(ruleContext, "ruleContext"); bool result = DateTime.Now.CompareTo(ruleContext.LastCommitted.AddMilliseconds(this.Threshold)) > 0; return(result); }
/// <summary> /// Rules engine condition implementation to determine whether a search index /// has been updated within the specified number of minutes. /// </summary> /// <param name="ruleContext">Rules processing context.</param> /// <returns>True if the index has not been updated /// within the specified number of minutes.</returns> protected override bool Execute(T ruleContext) { Assert.ArgumentNotNull(ruleContext, "ruleContext"); Assert.ArgumentNotNull(this.CompareLastUpdatedAgainstMinutes, "CompareLastUpdatedAgainstMinutes"); return(DateTime.Compare( ruleContext.LastUpdated.AddMinutes(this.CompareLastUpdatedAgainstMinutes.Value), DateTime.Now) < 0); }
protected override void Render(HtmlTextWriter writer) { string itemId = S.Web.WebUtil.GetQueryString("id"); Assert.IsNotNullOrEmpty(itemId, "itemId"); string dbName = S.Web.WebUtil.GetQueryString("database"); Assert.IsNotNullOrEmpty(dbName, "dbName"); S.Data.Database db = S.Configuration.Factory.GetDatabase(dbName); Assert.IsNotNull(db, "db: " + dbName); S.Data.Items.Item item = db.GetItem(itemId); Assert.IsNotNull(item, "item: " + itemId + " in " + dbName); string value = item["Type"]; Assert.IsNotNullOrEmpty(value, "value: Type of " + item.Paths.FullPath); string name = string.Empty; string dll = string.Empty; int comma = value.IndexOf(','); if (comma >= 0) { name = value.Substring(0, comma).Trim(); dll = value.Substring(comma + 1).Trim(); } Assembly assembly = S.Reflection.ReflectionUtil.LoadAssembly(dll); Assert.IsNotNull(assembly, "assembly: " + dll); Type type = assembly.GetType(name, false, true); if (type == null) { type = assembly.GetType(name + "`1"); } Assert.IsNotNull(type, "Type : " + name); dll = S.IO.FileUtil.MapPath("/bin/" + dll + ".dll"); Assert.IsTrue(File.Exists(dll), "dll.Exists(): " + dll); string tempFile = string.Format( "{0}.{1}.il", type, DateTime.Now.ToString("yyyyMMddTHHmmssffff")); S.IO.TempFolder.EnsureFolder(); tempFile = S.IO.FileUtil.MapPath( S.IO.FileUtil.MakePath(S.IO.TempFolder.Folder, tempFile, '/')); S.Sharedsource.Diagnostics.CommandLineTool clt = new S.Sharedsource.Diagnostics.CommandLineTool( "c:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v8.0A\\bin\\NETFX 4.0 Tools\\x64\\ildasm.exe"); clt.Execute( true /*log*/, "/source /html /linenum /item=" + type + " /out=" + tempFile + " " + dll); // /pubonly Assert.IsTrue(File.Exists(tempFile), "tempFile.Exists(): " + tempFile); this.Response.Output.Write(S.IO.FileUtil.ReadFromFile(tempFile)); this.Response.End(); File.Delete(tempFile); }
/// <summary> /// Deletes the old version. /// </summary> /// <param name="version">The old version to delete.</param> public override void HandleVersion(SC.Data.Items.Item version) { Assert.ArgumentNotNull(version, "version"); SC.Diagnostics.Log.Audit( this, "Delete version : {0}", new string[] { SC.Diagnostics.AuditFormatter.FormatItem(version) }); version.Versions.RemoveVersion(); }
/// <summary> /// Implementation allows index rebuilding if the system minute /// is between StartMinute and EndMinute minutes since midnight, inclusive. /// </summary> /// <param name="ruleContext">Rule processing context.</param> /// <returns>True if this condition allows index rebuilding.</returns> protected override bool Execute(T ruleContext) { Assert.ArgumentNotNull(ruleContext, "ruleContext"); Assert.ArgumentNotNull(this.StartMinute, "StartMinute"); Assert.ArgumentNotNull(this.EndMinute, "EndMinute"); DateTime now = DateTime.Now; int minutes = (now.Hour * 60) + now.Minute; return(minutes >= this.StartMinute.Value && minutes <= this.EndMinute.Value); }
/// <summary> /// Rules engine condition implementation to determine /// if the name of the database associated with an index /// matches a specific value. /// </summary> /// <param name="ruleContext">Rules processing context.</param> /// <returns>Returns true if the name of the database associated with the index /// matches the specified value.</returns> protected override bool Execute(T ruleContext) { Assert.ArgumentNotNull(ruleContext, "ruleContext"); Assert.ArgumentNotNull(ruleContext.IndexedDatabaseName, "ruleContext.IndexedDatabaseName)"); Assert.ArgumentNotNullOrEmpty(this.MatchIndexedDatabaseNameAgainst, "MatchIndexedDatabaseNameAgainst"); return(string.Equals( ruleContext.IndexedDatabaseName, this.MatchIndexedDatabaseNameAgainst, StringComparison.InvariantCultureIgnoreCase)); }
public override SC.Shell.Framework.Commands.CommandState QueryState(SC.Shell.Framework.Commands.CommandContext context) { Assert.ArgumentNotNull(context, "context"); SC.Shell.Framework.Commands.CommandState state = base.QueryState(context); if (context.Items.Length == 1 && context.Items[0] != null && state == SC.Shell.Framework.Commands.CommandState.Disabled && CheckIn.CanCheckIn(context.Items[0])) { return(SC.Shell.Framework.Commands.CommandState.Enabled); } return(state); }
public override void DoProcess( SC.Sharedsource.Pipelines.GetPresentationDataSources.GetPresentationDataSourcesArgs args) { Assert.ArgumentNotNull(args, "args"); if (!string.IsNullOrEmpty(args.RawDataSource)) { return; } args.DataSourceItems.Add(SC.Context.Item); }
/// <summary> /// Gets the first item from the list of items matched by the query. /// </summary> /// <param name="assertMaxOne">Throw an exception if there is more than one /// item in the list.</param> /// <param name="assertMinOne">Throw an exception if there is less than one /// item in the list.</param> /// <returns>The first item in the list of items matched by the query.</returns> public SC.Data.Items.Item GetSingleItem(bool assertMaxOne, bool assertMinOne) { if (assertMaxOne) { Assert.IsFalse(this.Items.Length > 1, "this.Items.Length > 1"); } if (assertMinOne) { Assert.IsFalse(this.Items.Length < 1, "this.Items.Length < 1"); } return(this.Items[0]); }
public GetPresentationDataSourcesArgs( string dataSource, SC.Data.Items.Item contextItem, bool storeUISearchResults, bool storeSearchResultIDs, CS.IProviderSearchContext searchContext) { Assert.ArgumentNotNull(contextItem, "contextItem"); this.RawDataSource = dataSource; this.ContextItem = contextItem; this.StoreUISearchResults = storeUISearchResults; this.StoreSearchResultIDs = storeSearchResultIDs; this.SearchContext = searchContext; }
internal static void ValidateArguments <TRequest, TResult>(ServicePipelineArgs args, out TRequest request, out TResult result) where TRequest : ServiceProviderRequest where TResult : ServiceProviderResult { Assert.ArgumentNotNull(args, nameof(args)); Assert.ArgumentNotNull(args.Request, "args.Request"); Assert.ArgumentNotNull(args.Request.RequestContext, "args.Request.RequestContext"); Assert.ArgumentNotNull(args.Result, "args.Result"); request = args.Request as TRequest; result = args.Result as TResult; Assert.IsNotNull(request, "The parameter args.Request was not of the expected type. Expected {0}. Actual {1}.", typeof(TRequest).Name, args.Request.GetType().Name); Assert.IsNotNull(result, "The parameter args.Result was not of the expected type. Expected {0}. Actual {1}.", typeof(TResult).Name, args.Result.GetType().Name); }
public static bool CanCheckIn(SC.Data.Items.Item item, SC.Security.Accounts.User user = null) { Assert.ArgumentNotNull(item, "item"); if (user == null) { user = SC.Context.User; Assert.IsNotNull(user, "context user"); } if (item.Appearance.ReadOnly || !item.Locking.IsLocked() || !item.Access.CanWrite() || !item.Access.CanWriteLanguage()) { return(false); } return(user.IsAdministrator || string.Compare(item.Locking.GetOwner(), user.Name, System.StringComparison.OrdinalIgnoreCase) == 0 || CheckIn.HasUnlockAccess(item)); }
/// <summary> /// Archives the old version. /// </summary> /// <param name="version">The old version to archive.</param> public override void HandleVersion(SC.Data.Items.Item version) { Assert.ArgumentNotNull(version, "version"); SC.Data.Archiving.Archive archive = version.Database.Archives["archive"]; if (archive != null) { SC.Diagnostics.Log.Audit( new object(), "Archive version: {0}", new string[] { SC.Diagnostics.AuditFormatter.FormatItem(version) }); archive.ArchiveVersion(version); } else { SC.Diagnostics.Log.Audit( this, "Recycle version : {0}", new string[] { SC.Diagnostics.AuditFormatter.FormatItem(version) }); version.RecycleVersion(); } }
protected void InvokeProcess(string arguments = null) { Assert.IsNotNullOrEmpty(this.CommandLine, "CommandLine"); ProcessStartInfo procStartInfo = new ProcessStartInfo(this.CommandLine) // ProcessStartInfo procStartInfo = new ProcessStartInfo("cmd") { WorkingDirectory = S.Configuration.Settings.LogFolder, RedirectStandardOutput = true, RedirectStandardError = true }; procStartInfo.UseShellExecute = false; // procStartInfo.WindowStyle = ProcessWindowStyle.Normal; // procStartInfo.LoadUserProfile = true; // procStartInfo.Arguments = "/c \"" + this.CommandLine + '"'; if (!string.IsNullOrEmpty(arguments)) { procStartInfo.Arguments = arguments; // procStartInfo.Arguments += " " + arguments; procStartInfo.Arguments += " " + arguments; } // procStartInfo.CreateNoWindow = false; Process process = new Process { StartInfo = procStartInfo }; Log.Info(this + " : invoke " + this.CommandLine + " " + procStartInfo.Arguments, this); process.Start(); process.WaitForExit(); this.ExitCode = process.ExitCode; this.StandardError = process.StandardError.ReadToEnd(); this.StandardOutput = process.StandardOutput.ReadToEnd(); process.Close(); }
protected new void Run(SC.Web.UI.Sheer.ClientPipelineArgs args) { Assert.ArgumentNotNull(args, "args"); if (!SC.Web.UI.Sheer.SheerResponse.CheckModified()) { return; } SC.Data.Items.Item item = SC.Client.GetItemNotNull(args.Parameters["id"], SC.Globalization.Language.Parse(args.Parameters["language"]), SC.Data.Version.Parse(args.Parameters["version"])); if (!(item.Locking.HasLock() || SC.Context.IsAdministrator || CheckIn.HasUnlockAccess(item))) { return; } SC.Diagnostics.Log.Audit(this, "Check in: {0}", new string[] { SC.Diagnostics.AuditFormatter.FormatItem(item) }); using (new SC.Data.Items.EditContext(item, SC.SecurityModel.SecurityCheck.Disable)) item.Locking.Unlock(); SC.Context.ClientPage.SendMessage(this, "item:checkedin"); }
/// <summary> /// Empty implementation. /// </summary> /// <param name="searchIndex">Search index.</param> public void Initialize(CS.ISearchIndex searchIndex) { Assert.ArgumentNotNull(searchIndex, "searchIndex"); Assert.ArgumentNotNullOrEmpty(searchIndex.Name, "searchIndex.Name"); if (!string.IsNullOrEmpty(this.RuleDatabaseName)) { return; } string[] parts = searchIndex.Name.Split('_'); if (parts.Length < 2) { return; } if (SC.StringUtil.Contains( parts[1], SC.Configuration.Factory.GetDatabaseNames())) { this.RuleDatabaseName = parts[1]; } }
// rewrite the Source property // set selectFirstItem now rather than parsing again later protected void ProcessSource(string originalSource) { if ((!string.IsNullOrEmpty(originalSource)) && this.Source.Contains("{itemfield:")) { MatchCollection matches = Regex.Matches( originalSource, "(?<match>\\{itemfield\\:(?<field>[^\\}]+)})"); Assert.IsTrue(matches.Count > 0, "matches > 0"); foreach (Match match in matches) { foreach (Group group in match.Groups) { originalSource = originalSource.Replace( match.Groups["match"].Value, this.CurrentItem[match.Groups["field"].Value]); } } } // If the Source contains a single value, convert it to a // key=value pair. if (originalSource.StartsWith("query:") || originalSource.StartsWith("~") || originalSource.StartsWith("/") || originalSource.StartsWith(".")) { originalSource = "DataSource=" + originalSource; } SC.Collections.SafeDictionary <string> parameters = SC.Web.WebUtil.ParseQueryString(originalSource); string databaseName = parameters["DatabaseName"]; if (String.IsNullOrEmpty(databaseName)) { this.database = this.CurrentItem.Database; } else { this.database = SC.Configuration.Factory.GetDatabase(databaseName); SC.Diagnostics.Assert.IsNotNull(this.database, "database"); } string dataSource = parameters["DataSource"]; if (!(string.IsNullOrEmpty(dataSource) || dataSource.StartsWith("~"))) { parameters["DataSource"] = this.ExpandDataSource(dataSource); } string sortBy = parameters["SortBy"]; if (!string.IsNullOrEmpty(sortBy)) { this.SortBy = sortBy; parameters.Remove("SortBy"); } string display = parameters["Display"]; if (!string.IsNullOrEmpty(display)) { this.Display = display; parameters.Remove("Display"); } string displayInTree = parameters["DisplayInTree"]; if (displayInTree != null) { this.DisplayFieldName = displayInTree; parameters.Remove("DisplayInTree"); } string includeItemsForDisplay = parameters["IncludeItemsForDisplay"]; if ((!string.IsNullOrEmpty(includeItemsForDisplay) && includeItemsForDisplay.StartsWith("query:"))) { parameters["IncludeItemsForDisplay"] = this.CalculateIncludeItemsForDisplay(includeItemsForDisplay); } this.selectFirstItem = parameters["SelectFirstItem"]; this.Source = SC.Web.WebUtil.BuildQueryString(parameters, false); }
protected static new bool CanCheckIn(SC.Data.Items.Item item) { Assert.ArgumentNotNull(item, "item"); return(CheckIn.CanCheckIn(item)); }
/// <summary> /// Nested logic for argument processing and possible UI alerts. /// </summary> private void Apply(object[] parameters) { Assert.ArgumentCondition( parameters != null && parameters.Length == 1 && parameters[0] is ClientPipelineArgs, "parameters", "//TODO"); ClientPipelineArgs args = parameters[0] as ClientPipelineArgs; // the FDA field of the item edited by the user Field field = this.Item.Fields[this.FieldID]; Assert.IsNotNull(field, "field"); FileDropAreaField fda = new FileDropAreaField( field, base.GetViewStateProperty("XmlValue", string.Empty) as string); ItemList mediaItems = fda.GetMediaItems(); if (mediaItems.Count < 1) { SheerResponse.Alert( Translate.Text("Add a media item.")); args.AbortPipeline(); return; } Item item = null; if (mediaItems.Count == 1) { item = mediaItems[0]; } else if (mediaItems.Count > 1) { ItemList selectedItems = null; try { // this may throw an exception; see 406891 selectedItems = this.GetSelectedItems(); } catch (Exception ex) { SheerResponse.Alert( Translate.Text("Select an item from the list.")); args.AbortPipeline(); return; } if (selectedItems.Count != 1) { SheerResponse.Alert( Translate.Text("Select a single item from the list.")); args.AbortPipeline(); return; } item = selectedItems[0]; } MediaItem mediaItem = new MediaItem(item); if (mediaItem.Extension != "docx") { SheerResponse.Alert(Translate.Text( "Seelect a Word document from the list.")); args.AbortPipeline(); return; } WordUtil.HandleWordDocument(this.Item, mediaItem); }
public CommitPolicyWrapper(SC.ContentSearch.ICommitPolicy policyToWrap) { Assert.ArgumentNotNull(policyToWrap, "policyToWrap"); this._wrappedPolicy = policyToWrap; }