public ServerResponseDto IsAuthorized(SecurityToken token)
{
return new ServerResponseDto
{
ResponseType = ServerResponseType.Ok,
};
}
public ClaimsPrincipal ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)
{
AuthenticationTicket ticket = _ticketDataFormat.Unprotect(securityToken);
validatedToken = null;
return ticket?.Principal;
}
public QueryRequest GetMetadataTypeInstancesQueryRequest(PageTypeCollection pageTypes, Guid languageId, SecurityToken token)
{
PageType pt = pageTypes.GetPageType("MetadataCategory");
if (pt != null)
{
return GetPageTypeInstancesQueryRequest(pt.ID, languageId, token);
}
return null;
}
public override string GetIssuerName(SecurityToken securityToken)
{
X509SecurityToken x509Token = securityToken as X509SecurityToken;
if (x509Token != null)
{
return x509Token.Certificate.SubjectName.Name;
}
throw new SecurityTokenException("Untrusted issuer.");
}
public ClaimsPrincipal ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)
{
validatedToken = null;
var claims = new[]
{
// Make sure to use a different name identifier
// than the one defined by CustomTokenValidated.
new Claim(ClaimTypes.NameIdentifier, "Bob le Tout Puissant"),
new Claim(ClaimTypes.Email, "*****@*****.**"),
new Claim(ClaimsIdentity.DefaultNameClaimType, "bob"),
};
return new ClaimsPrincipal(new ClaimsIdentity(claims));
}
public QueryRequest GetMetadataByNameQueryRequest(string name, Guid pageTypeId, Guid languageId, SecurityToken token)
{
// Set up page query.
var request = new QueryRequest(languageId, CmsSearchDomains.Pages, token);
// Set pagetype.
request.FilterTags.Add(new Tag(TagNames.PageTypeId, pageTypeId));
// Set pagetype.
request.FilterTags.Add(new Tag(TagNames.Name, name) { AllowFuzzy = false });
// Only published pages.
request.FilterTags.Add(new Tag(TagNames.IsPublished, true));
request.Paging = Paging.Default;
return request;
}
public void Run()
{
//for each request, you need an SecurityToken and a Int64
var cred = new ServiceUserPasswordCredentials();
cred._login = "******";
cred._passwordHash = "test".GetHashCode();
SecToken = _GraphDS_Service.LogOn(cred);
TransToken = _GraphDS_Service.BeginTransaction(SecToken);
Stopwatch RunningTime = new Stopwatch();
RunningTime.Start();
#region Run Tasks
Console.WriteLine("_________Generate DB Content:___________________________" + Environment.NewLine);
GenerateDBContent();
Console.Write(Environment.NewLine);
Console.WriteLine("_________Gather some data out of the DB:________________" + Environment.NewLine);
GatherData();
Console.Write(Environment.NewLine);
#endregion
RunningTime.Stop();
Console.WriteLine("________Example successful executed in " + RunningTime.ElapsedMilliseconds + " ms!______________"
+ Environment.NewLine + "Do you want to clear GraphDB? <y> | <n>");
switch (Console.ReadLine())
{
case "y":
_GraphDS_Service.Clear(SecToken, TransToken);
Console.WriteLine("GraphDB successful cleared!");
break;
default:
break;
}
Console.WriteLine("Press <Any Key> to end GraphDB Remote API Example!");
Console.ReadLine();
}
public ClaimsPrincipal ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)
{
validatedToken = null;
if (securityToken == DEMO_TOKEN)
{
// TODO: Complete all claims and other user data
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, DEMO_USERNAME),
new Claim(ClaimsIdentity.DefaultNameClaimType, DEMO_USERNAME),
new Claim(ClaimTypes.Email, DEMO_EMAIL)
};
return new ClaimsPrincipal(new ClaimsIdentity(claims, "Bearer") { BootstrapContext = securityToken });
}
else
{
throw new ApiException(new InvalidTokenProblem());
}
}
private static MessageHeader CreateWSSecurityHeader(SecurityToken token)
{
XmlElement tokenXml = null;
if (token is GenericXmlSecurityToken)
{
tokenXml = (token as GenericXmlSecurityToken).TokenXml;
}
else
{
var sb = new StringBuilder();
var writer = XmlWriter.Create(sb, new XmlWriterSettings { OmitXmlDeclaration = true });
var tokenHandlers = SecurityTokenHandlerCollection.CreateDefaultSecurityTokenHandlerCollection();
tokenHandlers.WriteToken(writer, token);
writer.Flush();
var doc = new XmlDocument();
doc.LoadXml(sb.ToString());
tokenXml = doc.DocumentElement;
}
var wsseHeader = MessageHeader.CreateHeader("Security", WSSecurity10Constants.Namespace, tokenXml, false);
return wsseHeader;
}
public void ValidateAudiencePublic(IEnumerable <string> audiences, SecurityToken token, TokenValidationParameters validationParameters)
{
base.ValidateAudience(audiences, token, validationParameters);
}
public ClaimsPrincipal ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)
{
var constructor = ExceptionType.GetTypeInfo().GetConstructor(new[] { typeof(string) });
var exception = (Exception)constructor.Invoke(new[] { ExceptionType.Name });
throw exception;
}
public static string GetPermisionFilterString(string tableName, string columnName, string permision, SecurityToken token)
{
if (token.SIDs.Contains(WellKnownSID.Administrators))
return null;
StringBuilder sb = new StringBuilder();
foreach(string sid in token.SIDs)
{
if(sb.Length != 0)
sb.Append(",");
sb.Append("'");
sb.Append(sid);
sb.Append("'");
}
string filter = String.Format("{0} IN(SELECT KeyValue FROM [BPMDB_GF].[dbo].BPMSecurityRecordACL WHERE TableName=N'{1}' AND Permision=N'{2}' AND SID IN({3}))",
//string filter = String.Format("{0} IN(SELECT KeyValue FROM BPMSecurityRecordACL WHERE TableName=N'{1}' AND Permision=N'{2}' AND (SID IN({3}) OR (LeadershipToken=1 AND SID IN(SELECT SID FROM BPMSecurityExtToken WHERE Account=N'{4}'))))",
columnName,
tableName,
permision,
sb.ToString(),
YZAuthHelper.LoginUserAccount);
return filter;
}
private List<Page> GetPagesFromSearchResponse(SearchResponse response, Litium.Foundation.Modules.CMS.Security.PermissionManager permissionManager, SecurityToken token)
{
List<Page> pages = new List<Page>();
if (response != null && response.Hits != null)
{
foreach (Hit hit in response.Hits)
{
Guid pageId = new Guid(hit.Id);
// Verify that page exists and user has permission to view page
if (Page.ExistsPage(pageId) && permissionManager.UserHasPageReadPermission(token.UserID, pageId, true, true))
{
// Fetch page from database
Page page = Page.GetFromID(pageId, token);
pages.Add(page);
}
}
}
return pages;
}
/// <summary>
/// Gets <see cref="Metadata"/> with complete set of information.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="searchService">The search service.</param>
/// <param name="permissionManager">The permission manager.</param>
/// <param name="token">The token.</param>
/// <returns></returns>
public List<Metadata> GetMetadatas(QueryRequest request, Litium.Foundation.Modules.CMS.Security.PermissionManager permissionManager, SecurityToken token)
{
// Perform search
SearchResponse response = Solution.Instance.SearchService.Search(request);
if (response == null)
{
_log.Error("Search returned null instead of zero results.");
return new List<Metadata>();
}
List<Page> pages = GetPagesFromSearchResponse(response, permissionManager, token);
List<Metadata> mds = new List<Metadata>();
foreach (Page page in pages)
{
mds.Add(new Metadata(page, this, token));
}
return mds;
}
public List<ProjectDescriptionDto> GetProjects(SecurityToken token)
{
return null;
}
/// <summary>
/// Attempt to add a new entry or update an existing entry.
/// </summary>
/// <param name="key">Key to use when adding item.</param>
/// <param name="securityToken">SecurityToken to add to cache, can be null.</param>
/// <param name="expirationTime">The expiration instant of the token being added.</param>
/// <exception cref="System.IdentityModel.LimitExceededException">Thrown if an attempt is made to add a SecurityToken if cache is at capacity.</exception>
/// <exception cref="InvalidOperationException">Thrown if the expiration time is infinite.</exception>
public override void AddOrUpdate(string key, SecurityToken securityToken, DateTime expirationTime)
{
if (DateTime.Equals(expirationTime, DateTime.MaxValue))
{
throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID1072));
}
_internalCache.TryRemove(key);
_internalCache.TryAdd(key, securityToken, expirationTime);
}
public IEnumerable <IVertex> GetVerticesByTypeID(SecurityToken mySecurityToken, Int64 myTransactionToken, long myTypeID, IEnumerable <long> myInterestingVertexIDs, IEnumerable <string> myInterestingEditionNames, IEnumerable <Int64> myInterestingRevisionIDs)
{
return(_vertexStore.GetVerticesByTypeID(mySecurityToken, myTransactionToken, myTypeID, myInterestingVertexIDs, myInterestingEditionNames, myInterestingRevisionIDs));
}
public IVertex GetVertex(SecurityToken mySecurityToken, Int64 myTransactionToken, long myVertexID, long myVertexTypeID, VertexStoreFilter.EditionFilter myEditionsFilterFunc = null, VertexStoreFilter.RevisionFilter myInterestingRevisionIDFilterFunc = null)
{
return(_vertexStore.GetVertex(mySecurityToken, myTransactionToken, myVertexID, myVertexTypeID, myEditionsFilterFunc, myInterestingRevisionIDFilterFunc));
}
public IVertex GetVertex(SecurityToken mySecurityToken, Int64 myTransactionToken, long myVertexID, long myVertexTypeID, string myEdition = null, Int64 myVertexRevisionID = 0L)
{
return(_vertexStore.GetVertex(mySecurityToken, myTransactionToken, myVertexID, myVertexTypeID, myEdition, myVertexRevisionID));
}
/// <summary>
/// Переопределяется для получения переопределенного списка с пунктами.
/// </summary>
/// <param name="token">Токен безопасности.</param>
/// <param name="list">Список который необходимо инициализировать.</param>
/// <param name="selectedId"> Выбранный пункт.</param>
/// <param name="parentValue">Значение родительского контрола.</param>
public override void GetInitializedItems(SecurityToken token, List <JSelectListItem <Guid> > list, Guid?selectedId, string parentValue)
{
UserHelper.PopulateUserList(list, selectedId, token, ProjectRoleSet.Engineer.ProjectRoleID);
}
private bool JwtHasValidAlgorithm(SecurityToken token)
{
return((token is JwtSecurityToken jwtSecurityToken) && jwtSecurityToken.Header.Alg.Equals(
SecurityAlgorithms.HmacSha256,
StringComparison.InvariantCultureIgnoreCase));
}
public override NameValueCollection Validate(TokenRequestMessage message)
{
if (!this.CanValidateMessage(message))
{
throw new OAuthException(OAuthErrorCodes.UnsupportedGrantType, "This handler cannot validate this message.");
}
if (!message.Parameters[OAuthConstants.AssertionType].Equals("saml", StringComparison.OrdinalIgnoreCase))
{
throw new OAuthException(OAuthErrorCodes.InvalidRequest, string.Format("Assertion format '{0}' not supported. Only Saml Supported", message.Parameters[OAuthConstants.AssertionType]));
}
string assertion = message.Parameters[OAuthConstants.Assertion];
if (assertion == null)
{
throw new OAuthException(OAuthErrorCodes.InvalidRequest, "Parameter 'assertion' is mandatory");
}
this.EnsureClientExists(message);
SecurityToken token = null;
SecurityToken xtoken = null;
using (var stringReader = new StringReader(assertion))
{
var reader = XmlReader.Create(stringReader);
if (!ServiceConfiguration.SecurityTokenHandlers.CanReadToken(reader))
{
throw new OAuthException(OAuthErrorCodes.UnsupportedGrantType, "No Token handler defined can read this assertion");
}
// TODO: this should be changed to be in config
// CHANGE: matias: read decryption cert from servicecertificate instead of hardcoding localhost
using (var xprovider = new X509SecurityTokenProvider(ServiceConfiguration.ServiceCertificate))
{
xtoken = xprovider.GetToken(new TimeSpan(10, 1, 1));
}
var outOfBandTokens = new Collection <SecurityToken>();
outOfBandTokens.Add(xtoken);
// CHANGED: matias, don't validate certificate (should be read from service config)
ServiceConfiguration.CertificateValidator = X509CertificateValidator.None;
// encryptedtoken handler is 6 . Add the X509TOken which has the key to decrypt this token
ServiceConfiguration.SecurityTokenHandlers[6].Configuration.ServiceTokenResolver =
SecurityTokenResolver.CreateDefaultSecurityTokenResolver(new ReadOnlyCollection <SecurityToken>(outOfBandTokens), false);
token = ServiceConfiguration.SecurityTokenHandlers.ReadToken(reader);
}
ClaimsIdentityCollection cc;
try
{
cc = ServiceConfiguration.SecurityTokenHandlers.ValidateToken(token);
}
catch (SecurityTokenException ex)
{
throw new OAuthException(OAuthErrorCodes.InvalidGrant, ex.Message, ex);
}
// CHANGE: matias: add CAM in order to be able to tranform claims
IClaimsPrincipal principal = new ClaimsPrincipal(cc);
if (ServiceConfiguration.ClaimsAuthenticationManager != null)
{
principal = ServiceConfiguration.ClaimsAuthenticationManager.Authenticate("replace", principal);
}
var collection = new NameValueCollection();
foreach (Claim claim in cc[0].Claims)
{
collection.Add(claim.ClaimType, claim.Value);
}
return(collection);
}
public static string GetTaskPermisionFilterString(string columnName,SecurityToken token)
{
if (token.SIDs.Contains(WellKnownSID.Administrators))
return null;
StringBuilder sb = new StringBuilder();
foreach(string sid in token.SIDs)
{
if(sb.Length != 0)
sb.Append(",");
sb.Append("'");
sb.Append(sid);
sb.Append("'");
}
string filter = String.Format("{0} IN(SELECT TaskID FROM BPMInstProcSteps WHERE OwnerAccount=N'{1}' OR AgentAccount=N'{1}' OR ConsignOwnerAccount=N'{1}') OR {0} IN(SELECT TaskID FROM BPMSecurityTACL WHERE AllowRead=1 AND SID IN({2}))",
columnName,
YZAuthHelper.LoginUserAccount,
sb.ToString());
return filter;
}
private void OnDeserialized(StreamingContext context)
{
if (!string.IsNullOrEmpty(SerializedIdentityToken))
{
try
{
// Deserialize the serialized identity token.
XmlTextReader xmlTextReader = new XmlTextReader(new StringReader(SerializedIdentityToken));
SerializableTokenWrapper<SecurityToken> deserializer = new SerializableTokenWrapper<SecurityToken>();
xmlTextReader.Read();
m_deserializedIdentityToken = deserializer.ReadToken(xmlTextReader);
}
catch
{
// Exception may be encountered when deserializing if authentication fails.
}
}
}
public QueryRequest GetPageTypeInstancesQueryRequest(Guid pageTypeId, Guid languageId, SecurityToken token)
{
// Set up page query.
var request = new QueryRequest(languageId, CmsSearchDomains.Pages, token);
// Set pagetype.
request.FilterTags.Add(new Tag(TagNames.PageTypeId, pageTypeId));
// Only published pages.
request.FilterTags.Add(new Tag(TagNames.IsPublished, true));
// Sort order.
Sorting sorting = new Sorting(TagNames.PageIndex, SortingFieldType.Int);
request.Sortings.Add(sorting);
// Fetch many.
request.Paging = new Paging(1, 999999);
return request;
}
public IEnumerable <IVertex> GetVerticesByTypeID(SecurityToken mySecurityToken, Int64 myTransactionToken, long myTypeID)
{
return(_vertexStore.GetVerticesByTypeID(mySecurityToken, myTransactionToken, myTypeID));
}
public QueryRequest GetPagesTaggedWithMetadataQueryRequest(List<Metadata> requiredMetadatas, List<Metadata> optionalMetadatas, Guid parentPageId, Guid webSiteId, SortType sortType, int pageIndex, int pageSize, Guid languageId, SecurityToken token)
{
var request = new QueryRequest(languageId, SearchDomains.Pages, token);
// Make sure page is searchable
request.FilterTags.Add(new Tag(TagNames.IsSearchable, bool.TrueString));
// Make sure pages are published
request.FilterTags.Add(new Tag(TagNames.IsPublished, bool.TrueString));
if (parentPageId != Guid.Empty)
{
// Only search pages under specified page
request.FilterTags.Add(new Tag(TagNames.PageParentTreeId, parentPageId));
}
if (webSiteId != Guid.Empty)
{
// Only search pages under specified web site
request.FilterTags.Add(new Tag(TagNames.WebSiteId, webSiteId));
}
// Add required metadatas as filter
foreach (Metadata metadata in requiredMetadatas)
{
request.FilterTags.Add(new Tag(TagNames.GetTagNameForProperty(Metadata.PropertyNameSelectedMetadata), metadata.ID));
}
if (optionalMetadatas != null && optionalMetadatas.Count > 0)
{
// Add optional metadatas
OptionalTagClause optionalMetadatasClause = new OptionalTagClause();
foreach (Metadata metadata in optionalMetadatas)
{
optionalMetadatasClause.FilterTags.Add(new Tag(TagNames.GetTagNameForProperty(Metadata.PropertyNameSelectedMetadata), metadata.ID));
}
request.FilterTags.Add(optionalMetadatasClause);
}
request.Paging = GetPaging(pageIndex, pageSize);
Sorting sorting = GetSortType(sortType);
if (sorting != null)
{
request.Sortings.Add(sorting);
}
return request;
}
public IEnumerable <IVertex> GetVerticesByTypeIDAndRevisions(SecurityToken mySecurityToken, Int64 myTransactionToken, long myTypeID, IEnumerable <Int64> myInterestingRevisions)
{
return(_vertexStore.GetVerticesByTypeIDAndRevisions(mySecurityToken, myTransactionToken, myTypeID, myInterestingRevisions));
}
public ServerResponseDto SetUserToProject(SecurityToken token,Guid userId, Guid projectId)
{
return null;
}
public IEnumerable <string> GetVertexEditions(SecurityToken mySecurityToken, Int64 myTransactionToken, long myVertexID, long myVertexTypeID)
{
return(_vertexStore.GetVertexEditions(mySecurityToken, myTransactionToken, myVertexID, myVertexTypeID));
}
/// <summary>
/// Sets the metadata on provided page, the metadata provided will be the only metadata saved on the page.
/// </summary>
/// <param name="collection">The collection.</param>
/// <param name="metadatas">A list of metadata to be saved on page.</param>
/// <param name="token">The token.</param>
public void SetMetadataOnPage(PropertyCollection collection, List<Metadata> metadatas, SecurityToken token)
{
StringShortProperty property = GetOrCreateMetadataProperty(collection, token);
if (property.ValueCount > 0)
property.DeleteAllValues(token);
foreach (Metadata metadata in metadatas)
{
property.SetValue(property.ValueCount, metadata.ID.ToString(), token);
}
}
public IEnumerable <Int64> GetVertexRevisionIDs(SecurityToken mySecurityToken, Int64 myTransactionToken, long myVertexID, long myVertexTypeID, IEnumerable <string> myInterestingEditions = null)
{
return(_vertexStore.GetVertexRevisionIDs(mySecurityToken, myTransactionToken, myVertexID, myVertexTypeID, myInterestingEditions));
}
public SecurityHeader(SecurityToken token)
{
this.token = token;
}
public bool RemoveVertexRevision(SecurityToken mySecurityToken, Int64 myTransactionToken, long myVertexID, long myVertexTypeID, string myInterestingEdition, Int64 myToBeRemovedRevisionID)
{
return(_vertexStore.RemoveVertexRevision(mySecurityToken, myTransactionToken, myVertexID, myVertexTypeID, myInterestingEdition, myToBeRemovedRevisionID));
}
public ClaimsPrincipal ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)
{
validatedToken = new TestSecurityToken();
_tokenValidator?.Invoke(securityToken);
var claims = new[]
{
// Make sure to use a different name identifier
// than the one defined by CustomTokenValidated.
new Claim(ClaimTypes.NameIdentifier, "Bob le Tout Puissant"),
new Claim(ClaimTypes.Email, "*****@*****.**"),
new Claim(ClaimsIdentity.DefaultNameClaimType, "bob"),
};
return(new ClaimsPrincipal(new ClaimsIdentity(claims, AuthenticationScheme)));
}
public bool RemoveVertexEdition(SecurityToken mySecurityToken, Int64 myTransactionToken, long myVertexID, long myVertexTypeID, string myToBeRemovedEdition)
{
return(_vertexStore.RemoveVertexEdition(mySecurityToken, myTransactionToken, myVertexID, myVertexTypeID, myToBeRemovedEdition));
}
//验证token
ClaimsPrincipal ISecurityTokenValidator.ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)
{
validatedToken = null;
//validationParameters.TOKEN
//TODO ValidateToken
if (securityToken != "abcdefg")
{
return(null);
}
//给Identity赋值
var identity = new ClaimsIdentity(JwtBearerDefaults.AuthenticationScheme);
identity.AddClaim(new Claim("name", "wyt"));
identity.AddClaim(new Claim(ClaimsIdentity.DefaultRoleClaimType, "admin"));
var principle = new ClaimsPrincipal(identity);
return(principle);
}
public bool RemoveVertex(SecurityToken mySecurityToken, Int64 myTransactionToken, long myVertexID, long myVertexTypeID)
{
return(_vertexStore.RemoveVertex(mySecurityToken, myTransactionToken, myVertexID, myVertexTypeID));
}
public SharePointContextToken(string issuer, string audience, DateTime validFrom, DateTime validTo, IEnumerable<JsonWebTokenClaim> claims, SecurityToken issuerToken, JsonWebSecurityToken actorToken)
: base(issuer, audience, validFrom, validTo, claims, issuerToken, actorToken)
{
}
public IVertex AddVertex(SecurityToken mySecurityToken, Int64 myTransactionToken, VertexAddDefinition myVertexDefinition, Int64 myVertexRevisionID = 0L, bool myCreateIncomingEdges = true)
{
return(_vertexStore.AddVertex(mySecurityToken, myTransactionToken, myVertexDefinition, myVertexRevisionID, myCreateIncomingEdges));
}
public QueryRequest GetPagesTaggedWithMetadataQueryRequest(Guid metadataId, Guid parentPageId, Guid webSiteId, Guid languageId, int pageIndex, int pageSize, SecurityToken token)
{
var request = new QueryRequest(languageId, SearchDomains.Pages, token);
// Make sure page is searchable
request.FilterTags.Add(new Tag(TagNames.IsSearchable, bool.TrueString));
// Make sure pages are published
request.FilterTags.Add(new Tag(TagNames.IsPublished, bool.TrueString));
if (parentPageId != Guid.Empty)
{
// Only search pages under specified page
request.FilterTags.Add(new Tag(TagNames.PageParentTreeId, parentPageId));
}
if (webSiteId != Guid.Empty)
{
// Only search pages under specified web site
request.FilterTags.Add(new Tag(TagNames.WebSiteId, webSiteId));
}
// Add required metadatas as filter
request.FilterTags.Add(new Tag(TagNames.GetTagNameForProperty(Metadata.PropertyNameSelectedMetadata), metadataId));
// Set paging
request.Paging = GetPaging(pageIndex, pageSize);
return request;
}
public IVertex UpdateVertex(SecurityToken mySecurityToken, Int64 myTransactionToken, long myToBeUpdatedVertexID, long myCorrespondingVertexTypeID, VertexUpdateDefinition myVertexUpdate, bool myCreateIncomingEdges = true, string myToBeUpdatedEditions = null, Int64 myToBeUpdatedRevisionIDs = 0L, bool myCreateNewRevision = false)
{
return(_vertexStore.UpdateVertex(mySecurityToken, myTransactionToken, myToBeUpdatedVertexID, myCorrespondingVertexTypeID, myVertexUpdate, myCreateIncomingEdges, myToBeUpdatedEditions, myToBeUpdatedRevisionIDs, myCreateNewRevision));
}
public string ValidateIssuerPublic(string issuer, SecurityToken token, TokenValidationParameters validationParameters)
{
return(base.ValidateIssuer(issuer, token, validationParameters));
}
public IEnumerable <IVertex> GetVerticesByTypeID(SecurityToken mySecurityToken, Int64 myTransactionToken, long myTypeID, string myEdition, VertexStoreFilter.RevisionFilter myInterestingRevisionIDFilterFunc)
{
return(_vertexStore.GetVerticesByTypeID(mySecurityToken, myTransactionToken, myTypeID, myEdition, myInterestingRevisionIDFilterFunc));
}
public QueryRequest GetPagesTaggedWithMetadataQueryRequest(List<Metadata> requiredMetadata, Guid parentPageId, Guid webSiteId, SortType sortType, int pageIndex, int pageSize, Guid languageId, SecurityToken token)
{
return GetPagesTaggedWithMetadataQueryRequest(requiredMetadata, new List<Metadata>(), parentPageId, webSiteId, sortType, pageIndex, pageSize, languageId, token);
}
public void RemoveVertices(SecurityToken mySecurityToken, Int64 myTransactionToken, long myVertexTypeID, IEnumerable <long> myToBeDeltedVertices = null)
{
_vertexStore.RemoveVertices(mySecurityToken, myTransactionToken, myVertexTypeID, myToBeDeltedVertices);
}
public string InviteEmail(InviteEmailFormModel inviteUser)
{
var user = userService.GetUsersByEmail(inviteUser.Email);
if (user != null)
{
if (!groupUserService.CanInviteUser(user.Id, inviteUser.GrouporGoalId))
return Resources.PersonJoined;
}
if (ModelState.IsValid)
{
Guid groupIdToken = Guid.NewGuid();
SecurityToken groupIdSecurity = new SecurityToken()
{
Token = groupIdToken,
ActualID = inviteUser.GrouporGoalId
};
securityTokenService.CreateSecurityToken(groupIdSecurity);
UserMailer.Invite(inviteUser.Email, groupIdToken).Send();
return Resources.InvitationSent;
}
else
return Resources.WrongEmail;
}
public ulong GetVertexCount(SecurityToken mySecurityToken, Int64 myTransactionToken, long myVertexTypeID)
{
return(_vertexStore.GetVertexCount(mySecurityToken, myTransactionToken, myVertexTypeID));
}
public ServerResponseDto RemoveUserFromProject(SecurityToken token, Guid userId, Guid projectId)
{
return null;
}
public long GetHighestVertexID(SecurityToken mySecurityToken, Int64 myTransactionToken, long myVertexTypeID)
{
return(_vertexStore.GetHighestVertexID(mySecurityToken, myTransactionToken, myVertexTypeID));
}
/// <summary>
/// Gets the metadata from provided list of ids
/// </summary>
/// <param name="metadataIds">The metadata ids.</param>
/// <param name="token">The token.</param>
/// <returns></returns>
public List<Metadata> GetMetadataFromIDs(List<Guid> metadataIds, SecurityToken token)
{
List<Page> pages = Page.GetFromIDs(metadataIds, token);
List<Metadata> mds = new List<Metadata>();
foreach (Page page in pages)
{
mds.Add(new Metadata(page, this, token));
}
return mds;
}
public void LogOff(SecurityToken toBeLoggedOfToken)
{
//do nothing
}
/// <summary>
/// Gets the metadatas from provided page.
/// </summary>
/// <param name="collection">The property collection to use.</param>
/// <param name="token">The token.</param>
/// <returns>A list of metadatas.</returns>
public List<Metadata> GetMetadatasFromPage(PropertyCollection collection, SecurityToken token)
{
List<Metadata> mds = new List<Metadata>();
StringShortProperty property = GetOrCreateMetadataProperty(collection, token);
if (property.ValueCount > 0)
{
for (int i = 0; i < property.ValueCount; i++)
{
string pageId = property.GetValue(i);
Guid id = new Guid(pageId);
if (id != Guid.Empty && Page.ExistsPage(id))
{
Page mdPage = Page.GetFromID(id, token);
mds.Add(new Metadata(mdPage, this, token));
}
}
}
return mds;
}
public bool Authenticate(SecurityToken mySecurityToken, ulong myToBeCheckedVertexID, ulong myCorrespondingVertexTypeID, Right myWantedAction = Right.Traverse)
{
throw new NotImplementedException();
}
private StringShortProperty GetOrCreateMetadataProperty(PropertyCollection collection, SecurityToken token)
{
StringShortProperty property = collection[Metadata.PropertyNameSelectedMetadata] as StringShortProperty;
if (property == null)
property = collection.CreateStringShortProperty(Metadata.PropertyNameSelectedMetadata, false, false, true, token);
return property;
}
public ClaimsPrincipal ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)
{
validatedToken = null;
if (securityToken != "abcdefg")
{
return(new ClaimsPrincipal());
}
var identity = new ClaimsIdentity(JwtBearerDefaults.AuthenticationScheme);
identity.AddClaim(new Claim("name", "jim"));
identity.AddClaim(new Claim("SuperAdminOnly", "true"));
identity.AddClaim(new Claim(ClaimsIdentity.DefaultRoleClaimType, "user"));
var principal = new ClaimsPrincipal(identity);
return(principal);
}
/// <summary>
/// Get a metadata by its name.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="token">The security token.</param>
/// <returns></returns>
public Metadata GetMetadata(QueryRequest request, SecurityToken token)
{
SearchResponse response = Solution.Instance.SearchService.Search(request);
if (response != null)
{
if (response.Hits.Count > 0)
{
foreach (Hit hit in response.Hits)
{
Guid pageId = new Guid(hit.Id);
if (Page.ExistsPage(pageId))
{
Page page = Page.GetFromID(pageId, token);
return new Metadata(page, this, token);
}
}
}
}
else
{
_log.Error("Search returned null instead of zero results.");
}
return null;
}
public ClaimsPrincipal ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)
{
if (ExceptionType == typeof(SecurityTokenInvalidAudienceException))
{
throw new SecurityTokenInvalidAudienceException("SecurityTokenInvalidAudienceException")
{
InvalidAudience = "Bad Audience"
};
}
if (ExceptionType == typeof(SecurityTokenInvalidIssuerException))
{
throw new SecurityTokenInvalidIssuerException("SecurityTokenInvalidIssuerException")
{
InvalidIssuer = "Bad Issuer"
};
}
if (ExceptionType == typeof(SecurityTokenInvalidLifetimeException))
{
throw new SecurityTokenInvalidLifetimeException("SecurityTokenInvalidLifetimeException")
{
NotBefore = new DateTime(2001, 1, 15),
Expires = new DateTime(2000, 2, 20),
};
}
if (ExceptionType == typeof(SecurityTokenNotYetValidException))
{
throw new SecurityTokenNotYetValidException("SecurityTokenNotYetValidException")
{
NotBefore = new DateTime(2045, 1, 15),
};
}
if (ExceptionType == typeof(SecurityTokenExpiredException))
{
throw new SecurityTokenExpiredException("SecurityTokenExpiredException")
{
Expires = new DateTime(2000, 2, 20),
};
}
else
{
throw new NotImplementedException(ExceptionType.Name);
}
}
public bool AllowedToCreateVertexType(SecurityToken mySecuritytoken)
{
return(true);
}
private string GetTokenString(JwtSecurityTokenHandler tokenHandler, SecurityToken securityToken)
{
return(tokenHandler.WriteToken(securityToken));
}
