public void Repo_Issuers_DeleteV1_Success() { var data = new TestDataFactory(UoW); data.Destroy(); data.CreateIssuers(); var issuer = UoW.Issuers.Get(QueryExpressionFactory.GetQueryExpression <tbl_Issuer>() .Where(x => x.Name == TestDefaultConstants.IssuerName).ToLambda()) .Single(); var claims = UoW.Claims.Delete(QueryExpressionFactory.GetQueryExpression <tbl_Claim>() .Where(x => x.IssuerId == issuer.Id).ToLambda()); var refreshes = UoW.Refreshes.Delete(QueryExpressionFactory.GetQueryExpression <tbl_Refresh>() .Where(x => x.IssuerId == issuer.Id).ToLambda()); var settings = UoW.Settings.Delete(QueryExpressionFactory.GetQueryExpression <tbl_Setting>() .Where(x => x.IssuerId == issuer.Id).ToLambda()); var states = UoW.States.Delete(QueryExpressionFactory.GetQueryExpression <tbl_State>() .Where(x => x.IssuerId == issuer.Id).ToLambda()); var roles = UoW.Roles.Delete(QueryExpressionFactory.GetQueryExpression <tbl_Role>() .Where(x => x.Audience.IssuerId == issuer.Id).ToLambda()); var audiences = UoW.Audiences.Delete(QueryExpressionFactory.GetQueryExpression <tbl_Audience>() .Where(x => x.IssuerId == issuer.Id).ToLambda()); UoW.Issuers.Delete(issuer); UoW.Commit(); }
public IActionResult UpdateV1([FromBody] RoleV1 model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var role = uow.Roles.GetAsNoTracking(QueryExpressionFactory.GetQueryExpression <tbl_Role>() .Where(x => x.Id == model.Id).ToLambda()) .SingleOrDefault(); if (role == null) { ModelState.AddModelError(MessageType.RoleNotFound.ToString(), $"Role:{model.Id}"); return(NotFound(ModelState)); } else if (role.IsDeletable && role.IsDeletable != model.IsDeletable) { ModelState.AddModelError(MessageType.RoleImmutable.ToString(), $"Role:{role.Id}"); return(BadRequest(ModelState)); } var result = uow.Roles.Update(map.Map <tbl_Role>(model)); uow.Commit(); return(Ok(map.Map <RoleV1>(result))); }
public IActionResult GetV1([FromBody] DataStateV1 state) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var result = new DataStateV1Result <RoleV1> { Data = map.Map <IEnumerable <RoleV1> >( uow.Roles.Get( map.MapExpression <Expression <Func <IQueryable <tbl_Role>, IQueryable <tbl_Role> > > >( QueryExpressionFactory.GetQueryExpression <tbl_Role>().ApplyState(state)), new List <Expression <Func <tbl_Role, object> > >() { x => x.tbl_AudienceRoles, x => x.tbl_UserRoles, })), Total = uow.Roles.Count( map.MapExpression <Expression <Func <IQueryable <tbl_Role>, IQueryable <tbl_Role> > > >( QueryExpressionFactory.GetQueryExpression <tbl_Role>().ApplyPredicate(state))) }; return(Ok(result)); } catch (QueryExpressionException ex) { ModelState.AddModelError(MessageType.ParseError.ToString(), ex.ToString()); return(BadRequest(ModelState)); } }
internal static string FileEntityToPath(IUnitOfWork uow, tbl_User user, tbl_UserFile file) { var path = string.Empty; var paths = new List <string> { }; var folder = uow.UserFolders.Get(QueryExpressionFactory.GetQueryExpression <tbl_UserFolder>() .Where(x => x.IdentityId == user.IdentityId && x.Id == file.FolderId).ToLambda()) .Single(); while (folder.ParentId != null) { paths.Add(folder.VirtualName); folder = folder.Parent; } for (int i = paths.Count() - 1; i >= 0; i--) { path += "/" + paths.ElementAt(i); } path += "/" + file.VirtualName; return(path); }
/// <summary> /// Adds a retrieve multiple request to the current OrganizationRequestCollection. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="requests">The requests.</param> /// <param name="anonymousTypeInitializer">The anonymous type initializer.</param> /// <param name="columnNameAndValuePairs">The column name and value pairs.</param> public static void AddRetrieveMultiple <T>(this OrganizationRequestCollection requests, Expression <Func <T, object> > anonymousTypeInitializer, params object[] columnNameAndValuePairs) where T : Entity { requests.Add(new RetrieveMultipleRequest { Query = QueryExpressionFactory.Create(anonymousTypeInitializer, columnNameAndValuePairs), }); }
public override int Run(string[] remainingArguments) { try { var keys = _uow.PublicKeys.Get(QueryExpressionFactory.GetQueryExpression <tbl_PublicKey>() .Where(x => x.IdentityId == null && x.Deletable == false).ToLambda(), new List <Expression <Func <tbl_PublicKey, object> > >() { x => x.PrivateKey, }); if (_delete) { ConsoleHelper.StdOutKeyPairs(keys.OrderBy(x => x.Created)); Console.Out.Write(" *** Enter GUID of public key to delete *** : "); var input = Guid.Parse(StandardInput.GetInput()); var pubKey = _uow.PublicKeys.Get(QueryExpressionFactory.GetQueryExpression <tbl_PublicKey>() .Where(x => x.Id == input).ToLambda(), new List <Expression <Func <tbl_PublicKey, object> > >() { x => x.PrivateKey, }).SingleOrDefault(); if (pubKey != null) { _uow.PublicKeys.Delete(QueryExpressionFactory.GetQueryExpression <tbl_PublicKey>() .Where(x => x.Id == pubKey.Id).ToLambda()); _uow.PrivateKeys.Delete(QueryExpressionFactory.GetQueryExpression <tbl_PrivateKey>() .Where(x => x.Id == pubKey.PrivateKeyId).ToLambda()); _uow.Commit(); } } else if (_deleteAll) { ConsoleHelper.StdOutKeyPairs(keys.OrderBy(x => x.Created)); _uow.PublicKeys.Delete(QueryExpressionFactory.GetQueryExpression <tbl_PublicKey>() .Where(x => x.IdentityId == null && x.Deletable == false).ToLambda()); _uow.PrivateKeys.Delete(QueryExpressionFactory.GetQueryExpression <tbl_PrivateKey>() .Where(x => x.IdentityId == null && x.Deletable == false).ToLambda()); _uow.Commit(); } else { ConsoleHelper.StdOutKeyPairs(keys.OrderBy(x => x.Created)); } return(StandardOutput.FondFarewell()); } catch (Exception ex) { return(StandardOutput.AngryFarewell(ex)); } }
public void CreateUrls() { if (foundAudience == null) { CreateAudiences(); } /* * create test client urls */ var url = new Uri(TestDefaultConstants.UriLink); foundAudienceUrl = _uow.Urls.Get(QueryExpressionFactory.GetQueryExpression <tbl_Url>() .Where(x => x.AudienceId == foundAudience.Id && x.UrlHost == (url.Scheme + "://" + url.Host) && x.UrlPath == url.AbsolutePath).ToLambda()) .SingleOrDefault(); if (foundAudienceUrl == null) { foundAudienceUrl = _uow.Urls.Create( _map.Map <tbl_Url>(new UrlV1() { AudienceId = foundAudience.Id, UrlHost = url.Scheme + "://" + url.Host, UrlPath = url.AbsolutePath, IsEnabled = true, })); _uow.Commit(); } }
public void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities) { if (!relatedEntities.Any()) { throw new ArgumentException("Must contain at least one related entity!", "relatedEntities"); } if (relatedEntities.Any(e => e.LogicalName != relatedEntities.First().LogicalName)) { throw new NotImplementedException("Don't currently Support different Entity Types for related Entities!"); } if (relationship.PrimaryEntityRole.GetValueOrDefault(EntityRole.Referenced) == EntityRole.Referencing) { throw new NotImplementedException("Referencing Not Currently Implemented"); } var referencedIdName = EntityHelper.GetIdAttributeName(entityName); var referencingIdName = EntityHelper.GetIdAttributeName(relatedEntities.First().LogicalName); if (referencedIdName == referencingIdName) { referencedIdName += "one"; referencingIdName += "two"; } foreach (var entity in relatedEntities. Select(e => QueryExpressionFactory.Create(relationship.SchemaName, referencedIdName, entityId, referencingIdName, e.Id)). Select(qe => Service.RetrieveMultiple(qe).ToEntityList <Entity>().FirstOrDefault()). Where(entity => entity != null)) { Service.Delete(entity); } }
public override int Run(string[] remainingArguments) { try { var configs = _uow.Settings.Get(QueryExpressionFactory.GetQueryExpression <tbl_Setting>() .Where(x => x.Deletable == true).ToLambda()); ConsoleHelper.StdOutSettings(configs); if (_configID == Guid.Empty) { Console.Out.Write(" *** Enter GUID of config to delete *** : "); _configID = Guid.Parse(StandardInput.GetInput()); } _uow.Settings.Delete(QueryExpressionFactory.GetQueryExpression <tbl_Setting>() .Where(x => x.Id == _configID && x.Deletable == true).ToLambda()); _uow.Commit(); return(StandardOutput.FondFarewell()); } catch (Exception ex) { return(StandardOutput.AngryFarewell(ex)); } }
public void CreateClaims() { if (foundIssuer == null) { CreateIssuers(); } /* * create test claims */ foundClaim = _uow.Claims.Get(QueryExpressionFactory.GetQueryExpression <tbl_Claim>() .Where(x => x.Type == TestDefaultConstants.ClaimName).ToLambda()) .SingleOrDefault(); if (foundClaim == null) { foundClaim = _uow.Claims.Create( _map.Map <tbl_Claim>(new ClaimV1() { IssuerId = foundIssuer.Id, Subject = TestDefaultConstants.ClaimSubject, Type = TestDefaultConstants.ClaimName, Value = AlphaNumeric.CreateString(8), ValueType = TestDefaultConstants.ClaimValueType, IsDeletable = true, })); _uow.Commit(); } }
public void Repo_Audiences_DeleteV1_Success() { var data = new TestDataFactory(UoW); data.Destroy(); data.CreateAudiences(); var audience = UoW.Audiences.Get(QueryExpressionFactory.GetQueryExpression <tbl_Audience>() .Where(x => x.Name == TestDefaultConstants.AudienceName).ToLambda()) .Single(); UoW.AuthActivity.Delete(QueryExpressionFactory.GetQueryExpression <tbl_AuthActivity>() .Where(x => x.AudienceId == audience.Id).ToLambda()); UoW.Refreshes.Delete(QueryExpressionFactory.GetQueryExpression <tbl_Refresh>() .Where(x => x.AudienceId == audience.Id).ToLambda()); UoW.Settings.Delete(QueryExpressionFactory.GetQueryExpression <tbl_Setting>() .Where(x => x.AudienceId == audience.Id).ToLambda()); UoW.States.Delete(QueryExpressionFactory.GetQueryExpression <tbl_State>() .Where(x => x.AudienceId == audience.Id).ToLambda()); UoW.Roles.Delete(QueryExpressionFactory.GetQueryExpression <tbl_Role>() .Where(x => x.AudienceId == audience.Id).ToLambda()); UoW.Audiences.Delete(audience); UoW.Commit(); }
public IActionResult RemoveFromClaimV1([FromRoute] Guid userID, [FromRoute] Guid claimID) { var user = uow.Users.Get(x => x.Id == userID) .SingleOrDefault(); if (user == null) { ModelState.AddModelError(MessageType.UserNotFound.ToString(), $"User:{userID}"); return(NotFound(ModelState)); } var claim = uow.Claims.Get(QueryExpressionFactory.GetQueryExpression <tbl_Claim>() .Where(x => x.Id == claimID).ToLambda()) .SingleOrDefault(); if (claim == null) { ModelState.AddModelError(MessageType.ClaimNotFound.ToString(), $"Claim:{claimID}"); return(NotFound(ModelState)); } if (uow.Users.IsInClaim(user, claim)) { uow.Users.RemoveClaim( new tbl_UserClaim() { UserId = user.Id, ClaimId = claim.Id, }); uow.Commit(); } return(NoContent()); }
public override int Run(string[] remainingArguments) { try { if (!string.IsNullOrEmpty(_privKeyPass)) { Console.Out.Write(" *** Enter password for the private key *** : "); _privKeyPass = StandardInput.GetHiddenInput(); } else { _privKeyPass = AlphaNumeric.CreateString(32); Console.Out.WriteLine($" *** The password for the private key *** : {_privKeyPass}"); } var privKey = KeyHelper.CreatePrivKey(_conf, _uow, _keyAlgo, _privKeySize, _privKeyPass, SignatureHashAlgorithm.SHA256); var pubKey = _uow.PublicKeys.Get(QueryExpressionFactory.GetQueryExpression <tbl_PublicKey>() .Where(x => x.PrivateKeyId == privKey.Id).ToLambda()) .Single(); Console.Out.WriteLine($"{privKey.KeyValue}"); Console.Out.WriteLine($"{pubKey.KeyValue}"); return(StandardOutput.FondFarewell()); } catch (Exception ex) { return(StandardOutput.AngryFarewell(ex)); } }
internal static tbl_UserFolder FolderPathToEntity(IUnitOfWork uow, tbl_User user, string path) { if (path.FirstOrDefault() == '/') { path = path.Substring(1); } var folder = uow.UserFolders.Get(QueryExpressionFactory.GetQueryExpression <tbl_UserFolder>() .Where(x => x.IdentityId == user.IdentityId && x.ParentId == null).ToLambda()) .SingleOrDefault(); if (string.IsNullOrWhiteSpace(path)) { return(folder); } foreach (var entry in path.Split("/")) { folder = uow.UserFolders.Get(QueryExpressionFactory.GetQueryExpression <tbl_UserFolder>() .Where(x => x.IdentityId == user.IdentityId && x.ParentId == folder.Id && x.VirtualName == entry).ToLambda()) .SingleOrDefault(); } ; return(folder); }
internal static void EnsureRootExists(IUnitOfWork uow, tbl_User user) { var folder = uow.UserFolders.Get(QueryExpressionFactory.GetQueryExpression <tbl_UserFolder>() .Where(x => x.IdentityId == user.IdentityId && x.ParentId == null).ToLambda()) .SingleOrDefault(); if (folder == null) { var now = DateTime.UtcNow; var newFolder = uow.UserFolders.Create( new tbl_UserFolder { Id = Guid.NewGuid(), IdentityId = user.IdentityId, ParentId = null, VirtualName = string.Empty, Created = now, LastAccessed = null, LastUpdated = null, ReadOnly = true, }); uow.Commit(); var callPath = $"{MethodBase.GetCurrentMethod().DeclaringType.Name}.{MethodBase.GetCurrentMethod().Name}"; Log.Information($"'{callPath}' '{user.IdentityAlias}' initialize '/'"); } }
public void LocalCrmTests_BasicCrud() { var c1 = new Contact { Id = Guid.NewGuid(), FirstName = "Joe", LastName = "Plumber" }; var c2 = new Contact { Id = Guid.NewGuid(), FirstName = "Bill", LastName = "Carpenter" }; var opp = new Opportunity { Id = Guid.NewGuid(), CustomerId = c1.ToEntityReference() }; var service = GetService(); service.Create(c1); service.Create(c2); service.Create(opp); Assert.IsNotNull(service.GetFirstOrDefault <Opportunity>(Opportunity.Fields.ParentContactId, c1.Id), "Failed Simple Lookup by Attribute Entity Reference"); Assert.AreEqual(1, service.GetEntitiesById <Contact>(c1.Id).Count, "Failed Simple Where In Lookup by Id"); var qe = QueryExpressionFactory.Create <Opportunity>(); qe.AddLink <Contact>(Opportunity.Fields.ParentContactId, "contactid", c => new { c.FirstName }); var otherC = service.GetFirstOrDefault(qe); Assert.IsNotNull(otherC, "Failed Simple Lookup with Linked Entity on Entity Reference"); Assert.AreEqual(c1.FirstName, otherC.GetAliasedEntity <Contact>().FirstName, "Failed Simple Lookup retrieving Linked Entity columns"); }
public void Repo_Claims_CreateV1_Success() { var data = new TestDataFactory(UoW); data.Destroy(); data.CreateClaims(); var issuer = UoW.Issuers.Get(QueryExpressionFactory.GetQueryExpression <uvw_Issuer>() .Where(x => x.Name == TestDefaultConstants.IssuerName).ToLambda()) .Single(); var result = UoW.Claims.Create( Mapper.Map <uvw_Claim>(new ClaimV1() { IssuerId = issuer.Id, Subject = TestDefaultConstants.ClaimSubject, Type = TestDefaultConstants.ClaimName, Value = AlphaNumeric.CreateString(8), ValueType = TestDefaultConstants.ClaimValueType, IsDeletable = false, })); UoW.Commit(); result.Should().BeAssignableTo <uvw_Claim>(); }
public void LocalCrmTests_RetrieveOuterJoinedColumn() { var service = GetService(); var contact = new Contact { FirstName = "Joe" }; contact.Id = service.Create(contact); // Create 2 opportunities service.Create(new Opportunity { CustomerId = contact.ToEntityReference() }); service.Create(new Opportunity()); var qe = QueryExpressionFactory.Create <Opportunity>(); qe.AddLink <Contact>(Opportunity.Fields.ParentContactId, Contact.Fields.ContactId, JoinOperator.LeftOuter, c => new { c.FirstName }); var entities = service.GetEntities(qe); Assert.AreEqual(2, entities.Count, "Two opportunities should have been returned!"); Assert.AreEqual(contact.FirstName, entities.First(o => o.ParentContactId != null).GetAliasedEntity <Contact>().FirstName, "First Name wasn't returned!"); Assert.IsNull(entities.First(o => o.ParentContactId == null).GetAliasedEntity <Contact>().FirstName, "Second Opportunity some how has a contact!"); }
public UserMntDeleteCommands() { IsCommand("user-mount-delete", "Delete user mount"); HasRequiredOption("u|user="******"Enter user that already exists", arg => { if (string.IsNullOrEmpty(arg)) { throw new ConsoleHelpAsException($" *** No user name given ***"); } _conf = (IConfiguration) new ConfigurationBuilder() .AddJsonFile("clisettings.json", optional: false, reloadOnChange: true) .Build(); var instance = new ContextService(InstanceContext.DeployedOrLocal); _uow = new UnitOfWork(_conf["Databases:AuroraEntities"], instance); _user = _uow.Users.Get(QueryExpressionFactory.GetQueryExpression <tbl_User>() .Where(x => x.IdentityAlias == arg).ToLambda(), new List <Expression <Func <tbl_User, object> > >() { x => x.tbl_UserMount, }).SingleOrDefault(); if (_user == null) { throw new ConsoleHelpAsException($" *** Invalid user '{arg}' ***"); } }); }
public void CreateRoles() { if (foundAudience == null) { CreateAudiences(); } /* * create test roles */ foundRole = _uow.Roles.Get(QueryExpressionFactory.GetQueryExpression <tbl_Role>() .Where(x => x.Name == TestDefaultConstants.RoleName).ToLambda()) .SingleOrDefault(); if (foundRole == null) { foundRole = _uow.Roles.Create( _map.Map <tbl_Role>(new RoleV1() { AudienceId = foundAudience.Id, Name = TestDefaultConstants.RoleName, IsEnabled = true, IsDeletable = true, })); _uow.Commit(); } }
public override int Run(string[] remainingArguments) { try { var expression = QueryExpressionFactory.GetQueryExpression <E_Role>(); if (!string.IsNullOrEmpty(_filter)) { expression = expression.Where(x => x.Name.Contains(_filter)); } _roles = _uow.Roles.Get(expression.ToLambda(), new List <Expression <Func <E_Role, object> > >() { x => x.AudienceRoles, x => x.RoleClaims, x => x.UserRoles, }) .TakeLast(_count); FormatOutput.Roles(_uow, _roles.OrderBy(x => x.Name)); return(StandardOutput.FondFarewell()); } catch (Exception ex) { return(StandardOutput.AngryFarewell(ex)); } }
/// <summary> /// Data is assumed to not be there, so use DeleteIfExists /// </summary> /// <param name="service"></param> protected virtual void CleanupDataPreInitialization(IOrganizationService service) { foreach (var entityType in EntityIdsByLogicalName) { var entityIdsToDelete = entityType.Value; if (!entityIdsToDelete.Any()) { continue; } var qe = QueryExpressionFactory.Create( new LateBoundQuerySettings(entityType.Key) { ActiveOnly = false, Columns = new ColumnSet(false), }). WhereIn(EntityHelper.GetIdAttributeName(entityType.Key), entityType.Value.Select(i => i.EntityId)); foreach (var entity in service.RetrieveMultiple(qe).Entities) { service.TryDelete(entityType.Key, entity.Id); } } }
public IActionResult GetV1([FromRoute] string audienceValue) { Guid audienceID; LambdaExpression expr = null; tbl_Audience audience = null; if (Guid.TryParse(audienceValue, out audienceID)) { expr = QueryExpressionFactory.GetQueryExpression <tbl_Audience>() .Where(x => x.Id == audienceID).ToLambda(); } else { expr = QueryExpressionFactory.GetQueryExpression <tbl_Audience>() .Where(x => x.Name == audienceValue).ToLambda(); } audience = uow.Audiences.Get(expr, new List <Expression <Func <tbl_Audience, object> > >() { x => x.tbl_AudienceRoles, x => x.tbl_Roles, x => x.tbl_Urls, }) .SingleOrDefault(); if (audience == null) { ModelState.AddModelError(MessageType.AudienceNotFound.ToString(), $"Audience:{audienceValue}"); return(NotFound(ModelState)); } return(Ok(map.Map <AudienceV1>(audience))); }
/// <summary> /// Adds a retrieve multiple request to the current OrganizationRequestCollection. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="requests">The requests.</param> /// <param name="columnSet">The column set.</param> /// <param name="columnNameAndValuePairs">The column name and value pairs.</param> public static void AddRetrieveMultiple <T>(this OrganizationRequestCollection requests, ColumnSet columnSet, params object[] columnNameAndValuePairs) where T : Entity { requests.Add(new RetrieveMultipleRequest { Query = QueryExpressionFactory.Create <T>(columnSet, columnNameAndValuePairs), }); }
public IActionResult GetTextsV1([FromBody] DataStateV1 state) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var result = new DataStateV1Result <EmailV1> { Data = map.Map <IEnumerable <EmailV1> >( uow.Audiences.Get( map.MapExpression <Expression <Func <IQueryable <uvw_TextQueue>, IQueryable <uvw_TextQueue> > > >( QueryExpressionFactory.GetQueryExpression <uvw_TextQueue>().ApplyState(state)))), Total = uow.Audiences.Count( map.MapExpression <Expression <Func <IQueryable <uvw_TextQueue>, IQueryable <uvw_TextQueue> > > >( QueryExpressionFactory.GetQueryExpression <uvw_TextQueue>().ApplyPredicate(state))) }; return(Ok(result)); } catch (QueryExpressionException ex) { ModelState.AddModelError(MessageType.ParseError.ToString(), ex.ToString()); return(BadRequest(ModelState)); } }
/// <summary> /// Gets the entity with the given Key Value Pair collection. Null is returned if it isn't found. /// </summary> /// <param name="service">open IOrganizationService</param> /// <param name="logicalName">The logical name</param> /// <param name="kvps">the KeyAttributes Collection</param> /// <param name="columnSet">Columns to retrieve.</param> /// <returns></returns> public static Entity GetEntityOrDefault(this IOrganizationService service, string logicalName, KeyAttributeCollection kvps, ColumnSet columnSet = null) { if (kvps.Count == 0) { throw new ArgumentException(nameof(kvps) + " must contain at least one kvp!", nameof(kvps)); } var qe = columnSet == null ? QueryExpressionFactory.Create(logicalName) : QueryExpressionFactory.Create(logicalName, columnSet); foreach (var kvp in kvps) { switch (kvp.Value) { case null: qe.WhereEqual(new ConditionExpression(kvp.Key, ConditionOperator.Null)); break; case EntityReference ef: qe.WhereEqual(kvp.Key, ef.Id); break; default: qe.WhereEqual(kvp.Key, kvp.Value); break; } } return(service.GetFirstOrDefault(qe)); }
public IActionResult UpdateV1([FromBody] IssuerV1 model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var issuer = uow.Issuers.GetAsNoTracking(QueryExpressionFactory.GetQueryExpression <tbl_Issuer>() .Where(x => x.Id == model.Id).ToLambda()) .SingleOrDefault(); if (issuer == null) { ModelState.AddModelError(MessageType.IssuerNotFound.ToString(), $"Issuer:{model.Id}"); return(NotFound(ModelState)); } if (issuer.IsDeletable && issuer.IsDeletable != model.IsDeletable) { ModelState.AddModelError(MessageType.IssuerImmutable.ToString(), $"Issuer:{issuer.Id}"); return(BadRequest(ModelState)); } var result = uow.Issuers.Update(map.Map <tbl_Issuer>(model)); uow.Commit(); return(Ok(map.Map <IssuerV1>(result))); }
public void Repo_Refreshes_CreateV1_Success() { var data = new TestDataFactory(UoW); data.Destroy(); data.CreateAudienceRefreshes(); var issuer = UoW.Issuers.Get(QueryExpressionFactory.GetQueryExpression <E_Issuer>() .Where(x => x.Name == TestDefaultConstants.IssuerName).ToLambda()) .Single(); var audience = UoW.Audiences.Get(QueryExpressionFactory.GetQueryExpression <E_Audience>() .Where(x => x.Name == TestDefaultConstants.AudienceName).ToLambda()) .Single(); var result = UoW.Refreshes.Create( Mapper.Map <E_Refresh>(new RefreshV1() { IssuerId = issuer.Id, AudienceId = audience.Id, RefreshType = ConsumerType.User.ToString(), RefreshValue = Base64.CreateString(8), ValidFromUtc = DateTime.UtcNow, ValidToUtc = DateTime.UtcNow.AddSeconds(60), })); UoW.Commit(); result.Should().BeAssignableTo <E_Refresh>(); }
private TypedQueryExpression <Account> ArrangeAccountLinkCaseLinkPhoneCall(IOrganizationService service) { // // Arrange // var id = service.Create(new Account()); var incident = new Incident() { Description = "Description", CustomerId = new EntityReference(Account.EntityLogicalName, id) }; incident.Id = service.Create(incident); service.Create(new PhoneCall { Subject = "Subject", RegardingObjectId = incident.ToEntityReference() }); var qe = QueryExpressionFactory.Create <Account>(); qe.AddLink <Incident>(Account.Fields.Id, Incident.Fields.CustomerId, i => new { i.Description }) .AddLink <PhoneCall>(Incident.Fields.Id, PhoneCall.Fields.RegardingObjectId, p => new { p.Subject }); return(qe); }
public IActionResult GetV1([FromRoute] string issuerValue) { Guid issuerID; LambdaExpression expr = null; tbl_Issuer issuer = null; if (Guid.TryParse(issuerValue, out issuerID)) { expr = QueryExpressionFactory.GetQueryExpression <tbl_Issuer>() .Where(x => x.Id == issuerID).ToLambda(); } else { expr = QueryExpressionFactory.GetQueryExpression <tbl_Issuer>() .Where(x => x.Name == issuerValue).ToLambda(); } issuer = uow.Issuers.Get(expr, new List <Expression <Func <tbl_Issuer, object> > >() { x => x.tbl_Audiences, x => x.tbl_Claims, }) .SingleOrDefault(); if (issuer == null) { ModelState.AddModelError(MessageType.IssuerNotFound.ToString(), $"Issuer:{issuerValue}"); return(NotFound(ModelState)); } return(Ok(map.Map <IssuerV1>(issuer))); }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); if(!Page.IsPostBack) { string query = Request.QueryString["q"]; if(!string.IsNullOrEmpty(query)) { QueryExpressionFactory factory = new QueryExpressionFactory(); factory.DefaultOperator = '&'; factory.SplitQueryCharacters = DaveSexton.DocProject.DocSites.DocSiteSearch.DefaultSearchProvider.SplitQueryCharacters; factory.IgnoredWords = DocSiteManager.Settings.SearchExcludedKeywords.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); factory.MinimumKeywordLength = DocSiteManager.Settings.SearchMinimumKeywordLength; factory.Optimize = false; QueryExpression expression = factory.CreateExpression(query); if(!(expression is EmptyQueryExpression)) { expression.Evaluate(delegate(QueryExpression expr) { TermQueryExpression term = expr as TermQueryExpression; if(term != null && !Keywords.Contains(term.Term)) Keywords.Add(term.Term); }); } // The index must always be created when a query is specified otherwise it will be generated // automatically _after_ the keywords are rendered, which means they'll all appear in "red". DaveSexton.DocProject.DocSites.DocSiteSearch.EnsureIndex(); keywordsListPanel.Visible = false; KeywordFirstLetter = null; } } }