public void AuthenticateUser_IdentityHasClaimTypes()
{
const string UserName = "******";
const string Password = "******";
SecurityManager.Logout();
SitefinityTestUtilities.ServerOperations.Users().CreateUser(UserName, Password, "*****@*****.**", "test", "test", true, "AuthenticateUser", "IdentityHasClaimTypes", SecurityConstants.AppRoles.FrontendUsers);
try
{
var model = new LoginFormModel();
model.Authenticate(new LoginFormViewModel()
{
UserName = UserName, Password = Password
}, SystemManager.CurrentHttpContext);
var currentIdentity = ClaimsManager.GetCurrentIdentity();
Assert.AreEqual(UserName, currentIdentity.Name, "The name of the current identity did not match the user.");
Assert.IsNotNull(currentIdentity.NameClaimType, "NameClaimType was not set in the current identity.");
Assert.IsNotNull(currentIdentity.RoleClaimType, "RoleClaimType was not set in the current identity.");
Assert.AreEqual("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name", currentIdentity.NameClaimType, "NameClaimType did not have the expected value.");
Assert.AreEqual("http://schemas.microsoft.com/ws/2008/06/identity/claims/role", currentIdentity.RoleClaimType, "RoleClaimType did not have the expected value.");
}
finally
{
SecurityManager.Logout();
SitefinityTestUtilities.ServerOperations.Users().DeleteUsers(new[] { UserName });
}
}
public ActionResult CreateTorrent(CreateTorrentModel torrentModel)
{
var user = ClaimsManager.GetCurrentIdentity();
var isUserAuthenticated = this.userService.CheckIfUserIsAuthenticated(user);
var isUserModerator = this.userService.CheckIfUserIsModerator(user);
if (!isUserAuthenticated || !isUserModerator)
{
return(this.RedirectToAction("Index"));
}
var dynamicModuleManager = this.dynamicModuleManagerProvider.DynamicModuleManager;
var imageManager = this.imageManagerProvider.ImageManager;
var torrentManager = this.torrentManagerProvider.TorrentManager;
var torrentItem = dynamicModuleManager.CreateDataItem(torrentType);
var currentUserId = SecurityManager.GetCurrentUserId();
this.torrentService.SetTorrentValues(torrentItem, torrentModel, currentUserId);
this.torrentService.SetTorrentImage(imageManager, torrentItem);
this.torrentService.SetTorrentFile(torrentManager, torrentItem);
dynamicModuleManager.Lifecycle.Publish(torrentItem);
dynamicModuleManager.SaveChanges();
return(this.RedirectToAction("TorrentDetails", new { urlName = torrentItem.UrlName }));
}
/// <summary>
/// Updates a user's profile in Sitefinity.
/// </summary>
public virtual void UpdateProfile(LoginModel model, IGigyaModuleSettings settings, ref LoginResponseModel response)
{
var userInfoResponse = ValidateRequest(model, settings);
if (userInfoResponse == null)
{
return;
}
var currentIdentity = ClaimsManager.GetCurrentIdentity();
var currentUsername = currentIdentity.Name;
List <MappingField> mappingFields = GetMappingFields(settings);
var gigyaModel = GetAccountInfo(model.Id, settings, userInfoResponse, mappingFields);
ThrowTestingExceptionIfRequired(settings, gigyaModel);
string username = GetCmsUsername(mappingFields, gigyaModel);
var success = MapProfileFieldsAndUpdate(currentUsername, username, settings, gigyaModel, mappingFields);
if (success)
{
response.RedirectUrl = settings.RedirectUrl;
response.Status = ResponseStatus.Success;
if (currentUsername != username)
{
AuthenticateUser(username, settings, false, gigyaModel, mappingFields);
}
}
}
/// <summary>
/// Executes checks which need to run for every request e.g. notifyLogin if CMS is running the session and extending the session if Gigya is managing it.
/// </summary>
/// <param name="context"></param>
/// <param name="settings"></param>
public static void ProcessRequestChecks(HttpContext context, IGigyaModuleSettings settings = null)
{
var currentNode = SiteMapBase.GetCurrentNode();
if (currentNode != null && currentNode.IsBackend)
{
return;
}
// don't need to do anything if the user is editing content in the CMS
var identity = ClaimsManager.GetCurrentIdentity();
if (identity.IsBackendUser)
{
return;
}
if (context.Items.Contains(_executedProcessRequestKey))
{
return;
}
context.Items[_executedProcessRequestKey] = true;
var settingsHelper = new GigyaSettingsHelper();
var logger = LoggerFactory.Instance();
var membershipHelper = new GigyaMembershipHelper(new GigyaApiHelper(settingsHelper, logger), logger);
var accountHelper = new GigyaAccountHelper(settingsHelper, logger, membershipHelper, settings);
accountHelper.LoginToGigyaIfRequired();
accountHelper.UpdateSessionExpirationCookieIfRequired(context);
}
public static bool IsUserLoggedIn(string roleName = null)
{
bool isUserLoggedIn = false;
var currentIdentity = ClaimsManager.GetCurrentIdentity();
if (currentIdentity.IsAuthenticated)
{
isUserLoggedIn = true;
}
if (!roleName.IsNullOrEmpty())
{
if (isUserLoggedIn)
{
var currUser = SitefinityHelper.GetUserById(ClaimsManager.GetCurrentIdentity().UserId);
if (currUser != null)
{
isUserLoggedIn = SitefinityHelper.IsUserInRole(currUser, roleName);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
return(isUserLoggedIn);
}
// GET: LoginStatus
public ActionResult Index()
{
var viewPath = FileHelper.GetPath("~/Mvc/Views/GigyaLoginStatus/Index.cshtml", ModuleClass.ModuleVirtualPath + "Gigya.Module.Mvc.Views.GigyaLoginStatus.Index.cshtml");
var currentIdentity = ClaimsManager.GetCurrentIdentity();
GigyaLoginStatusViewModel model = GetViewModel(currentIdentity);
return(View(viewPath, model));
}
public static User GetCurrentUser(string provider = "")
{
var identity = ClaimsManager.GetCurrentIdentity();
var user = UserManager.GetManager(provider).GetUser(identity.UserId);
return(user);
}
public static User GetCurrentUser()
{
var userIdentity = ClaimsManager.GetCurrentIdentity();
UserManager manager = UserManager.GetManager(userIdentity.MembershipProvider);
var user = manager.GetUser(userIdentity.Name);
return(user);
}
/// <summary>
/// Determines whether this instance can edit.
/// </summary>
/// <returns></returns>
public virtual bool CanEdit()
{
var currentIdentity = ClaimsManager.GetCurrentIdentity();
var canEdit = currentIdentity.IsUnrestricted ||
(!this.UserName.IsNullOrEmpty() && currentIdentity.Name == this.UserName) ||
this.UserName.IsNullOrEmpty();
return(canEdit);
}
/// <summary>
/// Logs a user into Gigya by calling NotifyLogin.
/// </summary>
/// <param name="currentIdentity"></param>
public override void LoginToGigyaIfRequired()
{
if (!_settings.EnableRaas)
{
_logger.Error("RaaS not enabled.");
return;
}
if (_settings.SessionProvider != GigyaSessionProvider.CMS)
{
return;
}
var identity = ClaimsManager.GetCurrentIdentity();
var currentIdentity = new CurrentIdentity
{
IsAuthenticated = identity.IsAuthenticated,
Name = identity.Name,
UID = identity.Name
};
var cookieName = "glt_" + _settings.ApiKey;
if (!currentIdentity.IsAuthenticated || HttpContext.Current.Request.Cookies[cookieName] != null)
{
// user not logged in
return;
}
// get UID if not the username
var uidMapping = _settings.MappedMappingFields.FirstOrDefault(i => i.GigyaFieldName == Constants.GigyaFields.UserId && !string.IsNullOrEmpty(i.CmsFieldName));
if (uidMapping != null && uidMapping.CmsFieldName != Constants.SitefinityFields.UserId)
{
// get member to find UID field
var userManager = UserManager.GetManager();
var currentUser = userManager.GetUser(identity.UserId);
if (currentUser == null)
{
_logger.Error(string.Format("Couldn't find member with username of {0} so couldn't sign them in.", currentIdentity.Name));
return;
}
var profileManager = UserProfileManager.GetManager();
var profile = profileManager.GetUserProfile <SitefinityProfile>(currentUser);
if (profile == null)
{
_logger.Error(string.Format("Couldn't find profile for member with username of {0} so couldn't sign them in.", currentIdentity.Name));
return;
}
currentIdentity.UID = profile.GetValue <string>(uidMapping.CmsFieldName);
}
// user logged into Umbraco but not Gigya so call notifyLogin to sign in
LoginToGigya(currentIdentity);
}
protected override CurrentIdentity GetCurrentIdentity()
{
var currentIdentity = ClaimsManager.GetCurrentIdentity();
return(new CurrentIdentity
{
IsAuthenticated = currentIdentity.IsAuthenticated,
Name = currentIdentity.Name
});
}
private Boolean IsUserAuthorized()
{
Boolean returnValue = false;
var identity = ClaimsManager.GetCurrentIdentity();
var currentUserGuid = identity.UserId;
if (currentUserGuid != Guid.Empty)
{
returnValue = true;
}
return(returnValue);
}
private ISearchJobsResponse GetJobSearchResultsResponse(JobSearchResultsFilterModel filterModel)
{
if (!this.PageSize.HasValue || this.PageSize.Value <= 0)
{
this.PageSize = PageSizeDefaultValue;
}
JXTNext_SearchJobsRequest request = JobSearchResultsFilterModel.ProcessInputToSearchRequest(filterModel, this.PageSize, PageSizeDefaultValue);
string sortingBy = this.Sorting;
if (filterModel != null && !filterModel.SortBy.IsNullOrEmpty())
{
sortingBy = filterModel.SortBy;
}
request.SortBy = JobSearchResultsFilterModel.GetSortEnumFromString(sortingBy);
ViewBag.SortOrder = JobSearchResultsFilterModel.GetSortStringFromEnum(request.SortBy);
ISearchJobsResponse response = _BLConnector.SearchJobs(request);
JXTNext_SearchJobsResponse jobResultsList = response as JXTNext_SearchJobsResponse;
ViewBag.Request = JsonConvert.SerializeObject(filterModel);
ViewBag.FilterModel = JsonConvert.SerializeObject(filterModel);
ViewBag.PageSize = (int)this.PageSize;
ViewBag.CssClass = this.CssClass;
if (jobResultsList != null)
{
ViewBag.TotalCount = jobResultsList.Total;
}
ViewBag.JobResultsPageUrl = SfPageHelper.GetPageUrlById(ResultsPageId.IsNullOrWhitespace() ? Guid.Empty : new Guid(ResultsPageId));
ViewBag.CurrentPageUrl = SfPageHelper.GetPageUrlById(SiteMapBase.GetActualCurrentNode().Id);
ViewBag.JobDetailsPageUrl = SfPageHelper.GetPageUrlById(DetailsPageId.IsNullOrWhitespace() ? Guid.Empty : new Guid(DetailsPageId));
ViewBag.EmailJobPageUrl = SfPageHelper.GetPageUrlById(EmailJobPageId.IsNullOrWhitespace() ? Guid.Empty : new Guid(EmailJobPageId));
ViewBag.HidePushStateUrl = this.HidePushStateUrl;
ViewBag.PageFullUrl = SfPageHelper.GetPageUrlById(SiteMapBase.GetActualCurrentNode().Id);
ViewBag.IsMember = SitefinityHelper.IsUserLoggedIn("Member");
var currentIdentity = ClaimsManager.GetCurrentIdentity();
if (currentIdentity.IsAuthenticated)
{
var currUser = SitefinityHelper.GetUserById(currentIdentity.UserId);
if (currUser != null)
{
ViewBag.Email = currUser.Email;
}
}
return(response);
}
private CommentResponse SubmitCommentInternal(CommentCreateRequest commentData, IThread thread, IAuthor author)
{
var cs = SystemManager.GetCommentsService();
var currentConfig = CommentsUtilitiesReflector.GetThreadConfigByType(thread.Type, thread.Key);
if (currentConfig.RequiresAuthentication)
{
if (author.Key.IsNullOrWhitespace() || author.Key == Guid.Empty.ToString())
{
throw new InvalidOperationException("Comment cannot be submitted at the moment. Please refresh the page and try again.");
}
}
if (currentConfig.EnableRatings)
{
if (commentData.Rating == null)
{
throw new InvalidOperationException("A message displayed when ratings are allowed and a comment is submitted without rating.");
}
if (CommentsUtilitiesReflector.GetCommentsByThreadForCurrentAuthorWithRating(thread.Key).Any())
{
throw new InvalidOperationException("Only one comment with rating is allowed per user.");
}
}
var authorIp = CommentsUtilitiesReflector.GetIpAddressFromCurrentRequest();
var commentProxy = new CommentProxy(commentData.Message, thread.Key, author, authorIp, commentData.Rating);
commentProxy.CustomData = commentData.CustomData;
if (currentConfig.RequiresApproval)
{
commentProxy.Status = StatusConstants.WaitingForApproval;
}
else
{
commentProxy.Status = StatusConstants.Published;
}
IComment newComment = cs.CreateComment(commentProxy);
var result = CommentsUtilitiesReflector.GetCommentResponse(newComment, ClaimsManager.GetCurrentIdentity().IsBackendUser);
if (commentData.Captcha != null)
{
CommentsUtilitiesReflector.RemoveCaptchaFromTempStorage(commentData.Captcha.Key);
}
ServiceUtility.DisableCache();
return(result);
}
public virtual ActionResult Index()
{
if (SystemManager.IsDesignMode || SystemManager.IsPreviewMode)
{
return(new EmptyResult());
}
var settings = _settingsHelper.GetForCurrentSite(true);
if (!settings.EnableRaas)
{
if (settings.DebugMode)
{
_logger.Debug("RaaS disabled so GigyaSettings not added to page.");
}
return(new EmptyResult());
}
if (string.IsNullOrEmpty(settings.ApiKey))
{
_logger.Error("Gigya API key not specified. Check settings on Administration -> Settings -> Gigya");
return(new EmptyResult());
}
// check if Sitefinity is the session leader and sign in if required
GigyaAccountHelper.ProcessRequestChecks(System.Web.HttpContext.Current, settings);
var identity = ClaimsManager.GetCurrentIdentity();
var currentIdentity = new CurrentIdentity
{
IsAuthenticated = identity.IsAuthenticated,
Name = identity.Name
};
var viewModel = _settingsHelper.ViewModel(settings, Url, currentIdentity);
viewModel.ErrorMessage = Res.Get(Constants.Resources.ClassId, Constants.Resources.ErrorMessage);
Page pageHandler = HttpHandlerExtensions.GetPageHandler(HttpContext.CurrentHandler);
// check if the widget is being rendered through Sitefinity or directly from the Razor view
viewModel.RenderScript = pageHandler == null || pageHandler.Header == null || pageHandler.Header.Controls == null;
if (!viewModel.RenderScript)
{
var script = this.GetScript(viewModel);
pageHandler.Header.Controls.Add((Control) new LiteralControl(script));
}
var viewPath = FileHelper.GetPath("~/Mvc/Views/GigyaSettings/Index.cshtml", ModuleClass.ModuleVirtualPath + "Gigya.Module.Mvc.Views.GigyaSettings.Index.cshtml");
return(View(viewPath, viewModel));
}
public string SetCustomFilterExpression(string filterExpression)
{
//gets the current user
var user = ClaimsManager.GetCurrentIdentity();
if (user.IsUnrestricted)
{
//Administrators are always unrestricted
filterExpression += "";
return(filterExpression);
}
//gets current user roles
var currentUserRoleNames = user.Roles.Select(a => a.Name).Where(b => b.StartsWith("pm-"));
List <Guid> taxonIds = new List <Guid>();
foreach (var roleName in currentUserRoleNames)
{
var taxonId = GetTaxaIdByCurrentRole(roleName);
if (taxonId != Guid.Empty)
{
taxonIds.Add(taxonId);
}
}
if (taxonIds.Count > 0)
{
//filter dynamic content items according to the current user roles
foreach (var taxonId in taxonIds)
{
filterExpression += string.Format(" AND Permissions.Contains(({0}))", taxonId.ToString());
}
}
//show the dynamic items that are with tag for everyone
var everyoneTaxa = permissionsTaxa.FirstOrDefault(p => p.Value.ToLower().Equals("pm-everyone"));
if (everyoneTaxa.Key != Guid.Empty)
{
if (filterExpression.Contains("Permissions"))
{
filterExpression += string.Format(" OR Visible = true AND Status = Live AND Permissions.Contains(({0}))", everyoneTaxa.Key);
}
else
{
filterExpression += string.Format(" AND Permissions.Contains(({0}))", everyoneTaxa.Key);
}
}
return(filterExpression);
}
public ActionResult DownloadTorrent(string fileName, string fileType)
{
var user = ClaimsManager.GetCurrentIdentity();
var isUserAuthenticated = this.userService.CheckIfUserIsAuthenticated(user);
if (!isUserAuthenticated)
{
return(this.RedirectToAction("Index"));
}
var file = this.torrentService.GetTorrentFile(fileName, fileType);
return(File(file, fileType, System.IO.Path.GetFileName(file)));
}
private void ValidatePermission(DynamicDetailContainer container)
{
DynamicContent[] detailItems = (DynamicContent[])container.DataSource;
DynamicContent item = detailItems[0];
var identity = ClaimsManager.GetCurrentIdentity();
var url = Request.Url.OriginalString;
var loginUrl = string.Format("~/Mxg/AuthService/SignInByHelix?ReturnUrl={0}", url.UrlDecode());
try
{
/*var manager = DynamicModuleManager.GetManager();
* Type contentType = TypeResolutionService
* .ResolveType("Telerik.Sitefinity.DynamicTypes.Model.ResourcesProtected.ProtectedResource");*/
if (item != null)
{
//var det = item?.Issec.DataItem as DynamicContent;
//var pressitem = manager.GetDataItem(contentType, new Guid(item.GetValue("Id").ToString()));
//bool isSecgrand = pressitem.IsSecurityActionTypeGranted(SecurityActionTypes.View);
bool isSecgrand = item.IsSecurityActionTypeGranted(SecurityActionTypes.View);
log.InfoFormat("title is {0}-:{1}, permission:{2}, userid:{3}, isNullGuid:{4}",
item.GetValue("Title"),
item.GetValue("Id"),
isSecgrand,
identity.UserId,
identity.UserId.IsNullOrEmptyGuid()
);
if (isSecgrand == false)
{
Response.Redirect(identity.UserId.IsNullOrEmptyGuid() ? loginUrl : "~/account/not-authorized");
}
}
// not login & not granded
}
catch (Exception ex)
{
log.InfoFormat("exception from get dynamic:{0}- inner:{1}", ex.Message, ex.InnerException?.Message);
//Response.Redirect("~/account/not-authorized");
Response.Redirect(identity.UserId.IsNullOrEmptyGuid() ? loginUrl : "~/account/not-authorized");
}
}
public static string GetLoggedInUserEmail()
{
string email = String.Empty;
if (IsUserLoggedIn()) // User already logged in
{
var currUser = SitefinityHelper.GetUserById(ClaimsManager.GetCurrentIdentity().UserId);
if (currUser != null)
{
email = currUser.Email;
}
}
return(email);
}
public ActionResult CreateTorrent()
{
var user = ClaimsManager.GetCurrentIdentity();
var isUserAuthenticated = this.userService.CheckIfUserIsAuthenticated(user);
var isUserModerator = this.userService.CheckIfUserIsModerator(user);
if (!isUserAuthenticated || !isUserModerator)
{
return(this.RedirectToAction("Index"));
}
var torrentModel = new CreateTorrentModel();
return(this.View("TorrentForm", torrentModel));
}
public ActionResult TorrentDetails(string urlName)
{
var user = ClaimsManager.GetCurrentIdentity();
var isUserAuthenticated = this.userService.CheckIfUserIsAuthenticated(user);
if (!isUserAuthenticated)
{
return(this.RedirectToAction("Index"));
}
var dynamicModuleManager = this.dynamicModuleManagerProvider.DynamicModuleManager;
var torrent = this.torrentService.GetTorrent(dynamicModuleManager, this.torrentType, urlName);
return(this.View("TorrentDetails", torrent));
}
private static string GetCurrentSitefinityUser()
{
var identity = ClaimsManager.GetCurrentIdentity();
var userId = identity.UserId;
if (userId != Guid.Empty)
{
var userProfile = UserProfileManager.GetManager().GetUserProfiles(userId).FirstOrDefault() as Telerik.Sitefinity.Security.Model.SitefinityProfile;
if (userProfile != null)
{
return(userProfile.FirstName + " " + userProfile.LastName);
}
}
return(String.Empty);
}
//public DiscountCalculatorCustom()
//{
// if (removedDiscount == null)
// {
// removedDiscount = new Dictionary<Guid, IList<CartDiscount>>();
// }
//}
protected override IList <CartDiscount> GetApplicableCartDiscounts(CartOrder cartOrder, decimal subTotal, User user, List <Role> userRoles)
{
var all = base.GetApplicableCartDiscounts(cartOrder, subTotal, user, userRoles);
var discounts = all;
if (discounts != null)
{
// Get Discount with specific code
var discount = discounts
.Where(d => d.DiscountType == DiscountType.Coupon && d.ParentDiscount.CouponCode.Contains("code"))
.FirstOrDefault();
if (discount != null)
{
var identity = ClaimsManager.GetCurrentIdentity();
if (identity != null && identity.UserId != null && identity.UserId != Guid.Empty)
{
User currentUser = UserManager.GetManager().GetUser(identity.UserId);
if (new CustomerRetriever().IsNewCustomer(currentUser))
{
if (this.addToRemovedDiscountDictionary)
{
foreach (var item in discounts)
{
AddToDictionary(cartOrder.Id, item);
}
}
// Apply only the coupon code discount
//for new customers and remove other discounts
discounts.Clear();
discounts.Add(discount);
}
else
{
if (this.addToRemovedDiscountDictionary)
{
AddToDictionary(cartOrder.Id, discount);
}
// Remove discount if not new customer
discounts.Remove(discount);
}
}
}
}
return(discounts);
}
protected void Page_Load(object sender, EventArgs e)
{
var user = ClaimsManager.GetCurrentIdentity();
if (!user.IsAuthenticated)
{
this.loginStatusLabel.Text = "Please authenticate in order to make the migration.";
return;
}
this.loginStatusLabel.Text = String.Format("You are logged in as: {0}. Good luck!", user.Name);
this.migrateDataBtn.Enabled = this.ddlMigrationType.SelectedValue != "-1";
if (!this.IsPostBack || Request["__EVENTTARGET"] == this.ddlMigrationType.ID)
{
this.BindDropDowns();
}
}
public static List <string> GetCurrentUserRoles()
{
List <string> roles = new List <string>();
// Get the current identity
var identity = ClaimsManager.GetCurrentIdentity();
// Get information about the user from the properties of the ClaimsIdentityProxy object
if (identity != null)
{
foreach (var rolesInfo in identity.Roles)
{
roles.Add(rolesInfo.Name);
}
}
return(roles);
}
protected void btnSend_Click(object sender, EventArgs e)
{
Page.Validate();
if (Page.IsValid)
{
string ipAddress = this.Page.Request.UserHostAddress;
var identity = ClaimsManager.GetCurrentIdentity();
var userId = identity != null ? identity.UserId : Guid.Empty;
FormsUtilities.SubmitForm(this.faa.Text, this.fab.Text, this.fac.Text, this.fad.Text,
this.fae.Text, this.faf.Text, ipAddress, userId, FreeTrialWidget.formName);
this.wrapper.Visible = false;
this.success.Visible = true;
}
}
protected void Page_Load(object sender, EventArgs e)
{
log = LogManager.GetLogger(typeof(Base));
_bodyCssClasses.Add(this.IsDesignMode() ? "backend" : "frontend");
_bodyCssClasses.AddRange(SiteMapPath.Select(p => "p-" + p.Key));
iMisFrm.Attributes["class"] = "hidden";
Guid id = ClaimsManager.GetCurrentIdentity().UserId;
if (!id.IsNullOrEmptyGuid())
{
//User usr = Telerik.Sitefinity.Security.UserManager.GetManager().GetUser(id);
iMisFrm.Src = string.Format("https://members.iafc.org/helix/MembershipSignIn/{0}/", ClaimsManager.GetCurrentIdentity().Name);
//https://members.iafc.org/helix/MembershipSignIn/Timmy1/true
//log.InfoFormat("willAct:{0}, name:{1}", string.Format("https://members.iafc.org/helix/MembershipSignIn/{0}/true", ClaimsManager.GetCurrentIdentity().Name), usr.UserName);
}
}
protected override ILifecycleDataItemGeneric ExecuteOnPublish(ILifecycleDataItemGeneric masterItem, ILifecycleDataItemGeneric liveItem, System.Globalization.CultureInfo culture = null, DateTime?publicationDate = null)
{
var identity = ClaimsManager.GetCurrentIdentity();
var userName = identity.Name;
if (masterItem is Image)
{
var imageItem = masterItem as Image;
if (liveItem != null && userName != "system")
{
imageItem.SetValue("Optimized", false);
}
return(base.ExecuteOnPublish(imageItem as ILifecycleDataItemGeneric, liveItem, culture, publicationDate));
}
else
{
return(base.ExecuteOnPublish(masterItem, liveItem, culture, publicationDate));
}
}
/// <inheritDoc/>
public virtual LoginFormViewModel Authenticate(LoginFormViewModel input, HttpContextBase context)
{
User user;
UserLoggingReason result = SecurityManager.AuthenticateUser(
this.MembershipProvider,
input.UserName,
input.Password,
input.RememberMe,
out user);
var identity = ClaimsManager.GetCurrentIdentity();
if (user != null && identity != null && identity.OriginalIdentity is SitefinityIdentity)
{
IClaimsPrincipal cp = new ClaimsPrincipal(new[] { new ClaimsIdentity(identity.Claims) });
var wifCredentials = new FederatedServiceCredentials(FederatedAuthentication.ServiceConfiguration);
cp = wifCredentials.ClaimsAuthenticationManager.Authenticate(context.Request.RequestType, cp);
SitefinityClaimsAuthenticationModule.Current.AuthenticatePrincipalWithCurrentToken(cp, input.RememberMe);
}
if (result == UserLoggingReason.Unknown)
{
input.IncorrectCredentials = true;
}
else
{
string redirectUrl;
if (!this.TryResolveUrlFromUrlReferrer(context, out redirectUrl))
{
redirectUrl = this.GetPageUrl(this.LoginRedirectPageId);
}
input.RedirectUrlAfterLogin = redirectUrl;
if (result != UserLoggingReason.Success)
{
SFClaimsAuthenticationManager.ProcessRejectedUser(context, input.RedirectUrlAfterLogin);
}
}
return(input);
}
protected override void InitializeControls(Telerik.Sitefinity.Web.UI.GenericContainer container)
{
base.InitializeControls(container);
List <string> taxonNames = new List <string>();
GetAllTaxonNamesForDataItem(taxonNames);
//gets the current user
var user = ClaimsManager.GetCurrentIdentity();
if (!user.IsUnrestricted)
{
//gets current user role names
var currentUserRoleNames = user.Roles.Select(r => r.Name.ToLower());
bool isDynamicItemAllowed = false;
//always allowed for everyone
if (taxonNames.Contains("pm-everyone"))
{
isDynamicItemAllowed = true;
return;
}
foreach (var roleName in currentUserRoleNames)
{
//filter dynamic items for Enterprise customers
if (taxonNames.Contains(roleName))
{
isDynamicItemAllowed = true;
break;
}
}
if (!isDynamicItemAllowed)
{
Redirect403();
}
}
}