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;
}
}
}
