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 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 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 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));
}
/// <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 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);
}
/// <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>
/// 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>
/// 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));
}
/// <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);
}
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);
}
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 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 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];
}
}
public CommitPolicyWrapper(SC.ContentSearch.ICommitPolicy policyToWrap)
{
Assert.ArgumentNotNull(policyToWrap, "policyToWrap");
this._wrappedPolicy = policyToWrap;
}
protected static new bool CanCheckIn(SC.Data.Items.Item item)
{
Assert.ArgumentNotNull(item, "item");
return(CheckIn.CanCheckIn(item));
}
