public ConcatenateFilesHandler(ContextAdapter context, ITusConcatenationStore concatenationStore)
: base(context, IntentType.ConcatenateFiles, LockType.NoLock)
{
UploadConcat = ParseUploadConcatHeader();
_concatenationStore = concatenationStore;
_expirationHelper = new ExpirationHelper(context.Configuration);
}
private List <RadioEpisode> PopulateEpisodeList(Item seriesRoot)
{
var cacheKey = seriesRoot.ID.ToString();
if (_cacheService.Contains(cacheKey))
{
return(_cacheService.Get <List <RadioEpisode> >(cacheKey));
}
var allRadioEpisodeItems =
seriesRoot.Axes.GetDescendants().Where(d => d.TemplateName == "Radio Episode").ToList();
var allRadioEpisodes = new List <RadioEpisode>();
foreach (var i in allRadioEpisodeItems)
{
var episode = BuildRadioEpisode(i);
allRadioEpisodes.Add(episode);
}
allRadioEpisodes = allRadioEpisodes.OrderBy(e => e.Date).ToList();
var expirationTime = ExpirationHelper.GetExpirationTime(HMPPS.Utilities.Settings.RadioEpisodesCacheTime);
_cacheService.Store(cacheKey, allRadioEpisodes, expirationTime);
return(allRadioEpisodes);
}
public string GenerateJwtToken(IEnumerable <Claim> claims, string jwtTokenSecurityKey)
{
var tokenHandler = new JwtSecurityTokenHandler();
var symmetricKey = Encoding.UTF8.GetBytes(jwtTokenSecurityKey);
var now = DateTime.UtcNow;
var expiration = ExpirationHelper.GetExpirationTime(86400); // 1 day in sec
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
TokenIssuerName = "self",
AppliesToAddress = _homePageAddress,
Lifetime = new Lifetime(now, expiration),
SigningCredentials = new SigningCredentials(
new InMemorySymmetricSecurityKey(symmetricKey),
"http://www.w3.org/2001/04/xmldsig-more#hmac-sha256",
"http://www.w3.org/2001/04/xmlenc#sha256"),
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
return(tokenString);
}
public IEnumerable <Claim> ExtractClaims(TokenResponse response, ClaimsPrincipal tokenClaims)
{
var claims = new List <Claim>();
var prisonerIdClaim = tokenClaims.FindFirst(c => c.Type == ClaimTypes.NameIdentifier);
if (prisonerIdClaim != null)
{
claims.Add(new Claim(ClaimTypes.NameIdentifier, prisonerIdClaim.Value.ToUpperInvariant()));
}
claims.AddRange(tokenClaims.FindAll(c => c.Type == ClaimTypes.GivenName || c.Type == "pnomisLocation"));
if (string.IsNullOrEmpty(claims.FirstOrDefault(c => c.Type == "pnomisLocation")?.Value))
{
_logManager.LogWarning($"ExtractClaims error: pnomisLocation is null or empty for {prisonerIdClaim?.Value}", typeof(TokenManager));
}
if (!string.IsNullOrWhiteSpace(response.AccessToken))
{
//claims.AddRange(await GetUserInfoClaimsAsync(response.AccessToken));
claims.Add(new Claim("access_token", response.AccessToken));
claims.Add(new Claim("expires_at", ExpirationHelper.GetExpirationTimeString(response.ExpiresIn)));
}
if (!string.IsNullOrWhiteSpace(response.RefreshToken))
{
claims.Add(new Claim("refresh_token", response.RefreshToken));
}
return(claims);
}
private async Task SetupExpiration(DocumentStore store)
{
var config = new ExpirationConfiguration
{
Disabled = false,
DeleteFrequencyInSec = 100,
};
await ExpirationHelper.SetupExpiration(store, Server.ServerStore, config);
}
public override void Process(HttpRequestArgs args)
{
// Not checking IDAM authentication of content editors
if ((new[] { "shell", "login", "admin" }).Contains(Context.Site.Name))
{
return;
}
// force login only for normal website usage, not for preview / debugging / experienceediting / profiling
if (!Context.PageMode.IsNormal)
{
return;
}
// Not checking IDAM auth for /-/speak/v1/assets/main.js
// Unfortunately it is requested with Context.Site.Name == "website" and Context.PageMode.IsNormal == true
if (Context.IsLoggedIn && Context.User.Domain.Name == "sitecore")
{
return;
}
Assert.ArgumentNotNull(args, "args");
var sitecoreUserLoggedIn = Context.IsLoggedIn;
var userData = _userDataService.GetUserIdamDataFromCookie(args.Context);
if (sitecoreUserLoggedIn && userData == null)
{
AuthenticationManager.Logout();
return;
}
if (!sitecoreUserLoggedIn && userData != null)
{
var user = BuildVirtualUser(userData);
AuthenticationManager.LoginVirtualUser(user);
}
if (sitecoreUserLoggedIn)
{
if (!Context.User.LocalName.Equals(userData.NameIdentifier))
{
LogoutAndClearUserData(args.Context);
return;
}
if (ExpirationHelper.IsExpired(userData.ExpiresAt))
{
var claims = RefreshUserIdamData(ref userData);
if (!claims.ToList().Any())
{
LogoutAndClearUserData(args.Context);
return;
}
_userDataService.SaveUserIdamDataToCookie(claims, args.Context);
}
var user = BuildVirtualUser(userData);
AuthenticationManager.LoginVirtualUser(user);
}
}
public WriteFileHandler(ContextAdapter context)
: base(context, IntentType.WriteFile, LockType.RequiresLock)
{
var checksumHeader = Request.GetHeader(HeaderConstants.UploadChecksum);
if (checksumHeader != null)
{
_checksum = new Checksum(checksumHeader);
}
_expirationHelper = new ExpirationHelper(Context.Configuration);
}
private async Task <bool> DisableExpiration(IDocumentStore store)
{
var config = new ExpirationConfiguration
{
Disabled = true,
DeleteFrequencyInSec = 100,
};
await ExpirationHelper.SetupExpiration(store, Server.ServerStore, config);
var database = await Databases.GetDocumentDatabaseInstanceFor(store);
return(database.ExpiredDocumentsCleaner != null);
}
private async Task SetupExpiration(DocumentStore store)
{
using (var session = store.OpenAsyncSession())
{
var config = new ExpirationConfiguration
{
Disabled = false,
DeleteFrequencyInSec = 100,
};
await ExpirationHelper.SetupExpiration(store, Server.ServerStore, config);
await session.SaveChangesAsync();
}
}
public void LogInHardcodedIdamUser(HttpContext context)
{
if (!Context.User.IsAuthenticated)
{
List<Claim> claims = new List<Claim>();
claims.Add(new Claim(ClaimTypes.NameIdentifier, "A1466AE"));
claims.Add(new Claim(ClaimTypes.GivenName, "Steven"));
claims.Add(new Claim("access_token", ""));
claims.Add(new Claim("refresh_token", ""));
claims.Add(new Claim("expires_at", ExpirationHelper.GetExpirationTimeString(86400)));
claims.Add(new Claim("pnomisLocation", "LEI"));
var userData = new UserIdamData(claims);
var _logManager = new SitecoreLogManager();
var _jwtTokenService = new JwtTokenService();
var _encryptionService = new EncryptionService(_logManager);
var _userDataService = new UserDataService(_encryptionService, _jwtTokenService, _logManager);
_userDataService.SaveUserIdamDataToCookie(claims, context);
var sitecoreUser = BuildVirtualUser(userData);
AuthenticationManager.LoginVirtualUser(sitecoreUser);
//WebUtil.Redirect(context.Request.Url.AbsoluteUri);
}
}
public async Task CanDeleteAllExpiredDocsAfterRunningTheExpirationBundle()
{
using (var store = GetDocumentStore())
{
var config = new ExpirationConfiguration
{
Disabled = false,
DeleteFrequencyInSec = 1000
};
await ExpirationHelper.SetupExpiration(store, Server.ServerStore, config);
var expiry = SystemTime.UtcNow.AddMinutes(-5);
var deleteList = new List <string>();
var batchSize = 10;
var batches = 5;
for (var i = 0; i < batches; i++)
{
using (var session = store.OpenAsyncSession())
{
for (var j = 0; j < batchSize; j++)
{
var item = new Item();
await session.StoreAsync(item);
deleteList.Add(item.Id);
var metadata = session.Advanced.GetMetadataFor(item);
metadata[Constants.Documents.Metadata.Expires] = expiry.ToString(DefaultFormat.DateTimeOffsetFormatsToWrite);
}
await session.SaveChangesAsync();
}
}
using (var session = store.OpenAsyncSession())
{
foreach (var toDelete in deleteList)
{
session.Delete(toDelete);
}
await session.SaveChangesAsync();
}
string lastId;
using (var session = store.OpenAsyncSession())
{
var item = new Item();
await session.StoreAsync(item);
lastId = item.Id;
var metadata = session.Advanced.GetMetadataFor(item);
metadata[Constants.Documents.Metadata.Expires] = SystemTime.UtcNow.AddMinutes(-1).ToString(DefaultFormat.DateTimeOffsetFormatsToWrite);
await session.SaveChangesAsync();
}
var database = await Databases.GetDocumentDatabaseInstanceFor(store);
ValidateTotalExpirationCount(batchSize);
var expiredDocumentsCleaner = database.ExpiredDocumentsCleaner;
await expiredDocumentsCleaner.CleanupExpiredDocs(batchSize);
ValidateTotalExpirationCount(0);
using (var session = store.OpenAsyncSession())
{
var item = await session.LoadAsync <Item>(lastId);
Assert.Null(item);
}
void ValidateTotalExpirationCount(int expected)
{
using (database.DocumentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
using (context.OpenReadTransaction())
{
var currentTime = database.Time.GetUtcNow();
var options = new ExpirationStorage.ExpiredDocumentsOptions(context, currentTime, false, batchSize);
var expired = database.DocumentsStorage.ExpirationStorage.GetExpiredDocuments(options, out _, CancellationToken.None);
var totalCount = 0;
if (expired != null)
{
foreach (var singleExpired in expired)
{
totalCount += singleExpired.Value.Count;
}
}
Assert.Equal(expected, totalCount);
}
}
}
}
public CreateFileHandler(ContextAdapter context, ITusCreationStore creationStore)
: base(context, IntentType.CreateFile, LockType.NoLock)
{
_creationStore = creationStore;
_expirationHelper = new ExpirationHelper(context.Configuration);
}
