public async Task OnGetAsync_InvalidId()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync_InvalidId)}";
var options = new DbContextOptionsBuilder <IdentityServerDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var role = new Role();
role.RoleClaims.Add(new RoleClaim());
role.RoleClaims.Add(new RoleClaim());
role.RoleClaims.Add(new RoleClaim());
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
ClaimsModel model;
IActionResult get;
// Act
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
model = new ClaimsModel(_roleManager.Object);
get = await model.OnGetAsync(Guid.Empty).ConfigureAwait(false);
}
// Assert
Assert.Null(model.Role);
Assert.Null(model.Claims);
Assert.IsType <NotFoundResult>(get);
}
public async Task OnPostAsync_InvalidModel()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
IActionResult post;
var client = new Client {
Id = Random.Next()
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
var claims = new ClaimsModel(context)
{
Client = new Client {
Id = Random.Next()
}
};
post = await claims.OnPostAsync().ConfigureAwait(false);
}
// Assert
Assert.IsType <PageResult>(post);
}
public async Task OnPostAsync_AllRemoved()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_AllRemoved)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
ClaimsModel claims;
IActionResult post;
var client = new Client
{
Id = Random.Next(),
Claims = new List <ClientClaim>
{
new ClientClaim {
Id = Random.Next()
}
}
};
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
claims = new ClaimsModel(context)
{
Client = new Client {
Id = client.Id
}
};
post = await claims.OnPostAsync().ConfigureAwait(false);
}
// Assert
using (var context = new OidcDbContext(options))
{
client = await context.Clients
.Include(x => x.Claims)
.SingleOrDefaultAsync(x => x.Id.Equals(client.Id))
.ConfigureAwait(false);
Assert.Empty(client.Claims);
}
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Client.Id), key);
Assert.Equal(claims.Client.Id, value);
});
}
public IActionResult Claims(Guid id)
{
var user = _dispatcher.Dispatch(new GetUserQuery {
Id = id, IncludeClaims = true, AsNoTracking = true
});
return(View(ClaimsModel.FromEntity(user)));
}
public IActionResult Claims(int id)
{
var client = _configurationDbContext.Clients
.Include(x => x.Claims)
.FirstOrDefault(x => x.Id == id);
return(View(ClaimsModel.FromEntity(client)));
}
public List <ClaimOutput> GetClaims(ClaimsModel model)
{
List <ClaimOutput> response;
response = claimRepository.GetClaims(model);
return(response);
}
public IActionResult Claims(Guid id)
{
var user = _dbContext.Set <User>()
.Include(x => x.Claims)
.AsNoTracking()
.FirstOrDefault(x => x.Id == id);
return(View(ClaimsModel.FromEntity(user)));
}
public async Task OnPostAsync_AllRemoved()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_AllRemoved)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var roleClaim = new RoleClaim
{
ClaimType = "Claim Type",
ClaimValue = "Claim Value"
};
var role = new Role
{
Name = "Role Name",
RoleClaims = new List <RoleClaim> {
roleClaim
}
};
using (var context = new OidcDbContext(options))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
var model = new ClaimsModel(_roleManager.Object)
{
Role = new Role {
Id = role.Id
}
};
get = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_roleManager.Verify(
x => x.RemoveClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(roleClaim.ClaimType) && y.Value.Equals(roleClaim.ClaimValue))),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(get);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Role.Id), key);
Assert.Equal(role.Id, value);
});
}
public async Task OnPostAsync_AllRemoved()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_AllRemoved)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var userClaim = new UserClaim
{
ClaimType = "Claim Type",
ClaimValue = "Claim Value"
};
var user = new User
{
Email = "Email",
Claims = new List <UserClaim> {
userClaim
}
};
using (var context = new OidcDbContext(options))
{
context.Add(user);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_userManager.Setup(x => x.Users).Returns(context.Users);
var model = new ClaimsModel(_userManager.Object)
{
UserModel = new User {
Id = user.Id
}
};
get = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_userManager.Verify(
x => x.RemoveClaimsAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <IEnumerable <Claim> >(y => y.SingleOrDefault(z => z.Type.Equals(userClaim.ClaimType) && z.Value.Equals(userClaim.ClaimValue)) != null)),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(get);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(User.Id), key);
Assert.Equal(user.Id, value);
});
}
public PkceAuthorizationCodeRequest Build()
{
_baseUrl = _baseUrl ?? System.Configuration.ConfigurationManager.AppSettings["BaseUrl"];
if (string.IsNullOrEmpty(_baseUrl))
{
throw new ArgumentException("BaseUrl is a required field");
}
if (string.IsNullOrEmpty(_clientId))
{
throw new ArgumentException("ClientId is a required field");
}
if (string.IsNullOrEmpty((_codeVerifier)))
{
throw new ArgumentException("CodeVerifier is a required field");
}
if (string.IsNullOrEmpty(_responseType))
{
throw new ArgumentException("ResponseType is a required field");
}
if (string.IsNullOrEmpty(_redirectUri))
{
throw new ArgumentException("RedirectUri is a required field");
}
if (_scopes == null)
{
throw new ArgumentException("Scope is a required field");
}
var claims = new ClaimsModel
{
UserInfo = new Dictionary <string, string>(),
IdToken = new Dictionary <string, string>()
};
((List <string>)_userInfoClaims).ForEach(c => claims.UserInfo.Add(c, null));
((List <string>)_idTokenClaims).ForEach(c => claims.IdToken.Add(c, null));
return(new PkceAuthorizationCodeRequest
{
BaseUrl = _baseUrl,
ClientId = _clientId,
CodeChallenge = _codeVerifier.ToSha256().ToBase64UrlSafeNoPadding(),
CodeChallengeMethod = "S256",
RedirectUri = _redirectUri,
ResponseType = _responseType,
Scopes = _scopes,
State = _state,
Claims = claims
});
}
public ActionResult Index()
{
ViewBag.Filtro = CriaListaMenu();
ClaimsModel claimsModel = new ClaimsModel();
claimsModel = Session["Claims"] as ClaimsModel;
Session["nomeUsuario"] = claimsModel.UserName;
//Teste
return(View());
}
public ClaimsModel GetClaims(int page, int perPage)
{
HttpResponseMessage response = client.GetAsync(string.Format("https://arionapi-sandbox.azure-api.net/claims/v1/claims?page={0}&perPage={1}", page, perPage)).Result;
var claims = new ClaimsModel();
if (response.IsSuccessStatusCode)
{
var responseContent = response.Content.ReadAsStringAsync().Result;
claims = JsonConvert.DeserializeObject <ClaimsModel>(responseContent);
}
return(claims);
}
public void Init(string applicationName, string privateKey, ClaimsModel claims)
{
_privateKey = privateKey;
SetClaims(claims);
// Create Google Sheets API service.
_service = new SheetsService(
new BaseClientService.Initializer()
{
ApplicationName = applicationName
}
);
}
public async Task OnGetAsync_InvalidId()
{
// Arrange
var model = new ClaimsModel(new Mock <IConfigurationDbContext>().Object);
// Act
var get = await model.OnGetAsync(0).ConfigureAwait(false);
// Assert
Assert.Null(model.Client);
Assert.Null(model.Claims);
Assert.IsType <NotFoundResult>(get);
}
public async Task OnGetAsync()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var user = new User
{
Claims = new List <UserClaim>
{
new UserClaim {
ClaimType = "Claim 1 Type"
},
new UserClaim {
ClaimType = "Claim 2 Type"
},
new UserClaim {
ClaimType = "Claim 3 Type"
}
}
};
using (var context = new OidcDbContext(options))
{
context.Add(user);
await context.SaveChangesAsync().ConfigureAwait(false);
}
ClaimsModel model;
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_userManager.Setup(x => x.Users).Returns(context.Users);
model = new ClaimsModel(_userManager.Object);
get = await model.OnGetAsync(user.Id).ConfigureAwait(false);
}
// Assert
Assert.NotNull(model.UserModel);
Assert.Equal(user.Id, model.UserModel.Id);
var claims = Assert.IsAssignableFrom <IEnumerable <UserClaim> >(model.Claims);
Assert.Equal(user.Claims.Count, claims.Count());
Assert.IsType <PageResult>(get);
}
public async Task OnPostAsync_InvalidId()
{
// Arrange
var context = new Mock <IConfigurationDbContext>();
var claims = new ClaimsModel(context.Object)
{
Client = new Client {
Id = 0
}
};
// Act
var post = await claims.OnPostAsync().ConfigureAwait(false);
// Assert
context.Verify(x => x.SaveChangesAsync(), Times.Never);
Assert.IsType <PageResult>(post);
}
public ClaimsModel ObtemDadosLogin()
{
var userPrinciple = User as ClaimsPrincipal;
Session["AccessToken"] = userPrinciple.Claims.First(claim => claim.Type == "access_token").Value;
Session["nomeUsuario"] = userPrinciple.Identity.Name;
//var jwt = userPrinciple.Claims.First(claim => claim.Type == "access_token").Value;
//var handler = new JwtSecurityTokenHandler();
//var token = handler.ReadJwtToken(jwt);
var stream = userPrinciple.Claims.First(claim => claim.Type == "access_token").Value;
var handler = new JwtSecurityTokenHandler();
var jsonToken = handler.ReadToken(stream);
var tokenS = jsonToken as JwtSecurityToken;
ClaimsModel mdl = new ClaimsModel();
Roles roles = new Roles();
foreach (var item in tokenS.Claims)
{
if (item.Type == "azp")
{
mdl.AudApp = item.Value;
}
if (item.Type == "realm_access")
{
mdl.RealmAccess = item.Value;
}
if (item.Type == "resource_access")
{
mdl.ResourceAccess = item.Value;
}
if (item.Type == "preferred_username")
{
mdl.UserName = item.Value;
}
if (item.Type == "user_roles")
{
roles.Nome = item.Value;
mdl.Roles.Add(roles);
}
}
return(mdl);
}
public IActionResult GetClaims([FromBody] ClaimsModel model)
{
if (!ModelState.IsValid)
{
var error = ModelState.Values.FirstOrDefault().Errors.FirstOrDefault().ErrorMessage;
return(BadRequest(new { error_occured = true, error_message = error }));
}
try
{
var data = _imisModules.GetClaimModule().GetClaimLogic().GetClaims(model);
return(Ok(new { error_occured = false, data = data }));
}
catch (Exception e)
{
throw new BusinessException(HttpStatusCode.BadRequest, e.Message);
}
}
public static int SaveClaims(ClaimsModel model)
{
string query = "SaveClaims";
DbParameter[] ObjParam = new DbParameter[33];
ObjParam[0] = new DbParameter("@pkiClaimID", DbParameter.DbType.Int, 0, model.pkiClaimID);
ObjParam[1] = new DbParameter("@fkiMemberID", DbParameter.DbType.Int, 0, model.fkiMemberID);
ObjParam[2] = new DbParameter("@MemberNumber", DbParameter.DbType.NVarChar, 0, model.MemberNumber);
ObjParam[3] = new DbParameter("@ClaimDate", DbParameter.DbType.DateTime, 0, model.ClaimDate);
ObjParam[4] = new DbParameter("@ClaimNotes", DbParameter.DbType.NVarChar, 0, model.ClaimNotes);
ObjParam[5] = new DbParameter("@CourseOfDearth", DbParameter.DbType.NVarChar, 0, model.CourseOfDearth);
ObjParam[6] = new DbParameter("@HostingFuneral", DbParameter.DbType.Bit, 0, model.HostingFuneral);
ObjParam[7] = new DbParameter("@ClaimantTitle", DbParameter.DbType.NVarChar, 0, model.ClaimantTitle);
ObjParam[8] = new DbParameter("@ClaimantFullname", DbParameter.DbType.NVarChar, 0, model.ClaimantFullname);
ObjParam[9] = new DbParameter("@ClaimantSurname", DbParameter.DbType.NVarChar, 0, model.ClaimantSurname);
ObjParam[10] = new DbParameter("@ClaimantIDNumber", DbParameter.DbType.NVarChar, 0, model.ClaimantIDNumber);
ObjParam[11] = new DbParameter("@ClaimantDateOfBirth", DbParameter.DbType.DateTime, 0, model.ClaimantDateOfBirth);
ObjParam[12] = new DbParameter("@ClaimantGender", DbParameter.DbType.NVarChar, 0, model.ClaimantGender);
ObjParam[13] = new DbParameter("@ClaimantAddressLine1", DbParameter.DbType.NVarChar, 0, model.ClaimantAddressLine1);
ObjParam[14] = new DbParameter("@ClaimantAddressLine2", DbParameter.DbType.NVarChar, 0, model.ClaimantAddressLine2);
ObjParam[15] = new DbParameter("@ClaimantAddressLine3", DbParameter.DbType.NVarChar, 0, model.ClaimantAddressLine3);
ObjParam[16] = new DbParameter("@ClaimantAddressLine4", DbParameter.DbType.NVarChar, 0, model.ClaimantAddressLine4);
ObjParam[17] = new DbParameter("@ClaimantCode", DbParameter.DbType.NVarChar, 0, model.ClaimantCode);
ObjParam[18] = new DbParameter("@ClaimantContactNumber", DbParameter.DbType.NVarChar, 0, model.ClaimantContactNumber);
ObjParam[19] = new DbParameter("@BeneficiaryBank", DbParameter.DbType.NVarChar, 0, model.BeneficiaryBank);
ObjParam[20] = new DbParameter("@BeneficiaryAccountHolder", DbParameter.DbType.NVarChar, 0, model.BeneficiaryAccountHolder);
ObjParam[21] = new DbParameter("@BeneficiaryAccountNumber", DbParameter.DbType.NVarChar, 0, model.BeneficiaryAccountNumber);
ObjParam[22] = new DbParameter("@BeneficiaryBankBranch", DbParameter.DbType.NVarChar, 0, model.BeneficiaryBankBranch);
ObjParam[23] = new DbParameter("@BeneficiaryBranchCode", DbParameter.DbType.NVarChar, 0, model.BeneficiaryBranchCode);
ObjParam[24] = new DbParameter("@BeneficiaryAccountType", DbParameter.DbType.NVarChar, 0, model.BeneficiaryAccountType);
ObjParam[25] = new DbParameter("@LoggedBy", DbParameter.DbType.NVarChar, 0, model.LoggedBy);
ObjParam[26] = new DbParameter("@Cover", DbParameter.DbType.Money, 0, model.Cover);
ObjParam[27] = new DbParameter("@BodyCollectedFrom", DbParameter.DbType.NVarChar, 0, model.BodyCollectedFrom);
ObjParam[28] = new DbParameter("@ClaimingFor", DbParameter.DbType.NVarChar, 0, model.ClaimingFor);
ObjParam[29] = new DbParameter("@parlourid", DbParameter.DbType.UniqueIdentifier, 0, model.parlourid);
ObjParam[30] = new DbParameter("@ModifiedUser", DbParameter.DbType.VarChar, 0, model.ModifiedUser);
ObjParam[31] = new DbParameter("@Payout", DbParameter.DbType.Bit, 0, model.Payout);
ObjParam[32] = new DbParameter("@PayoutValue", DbParameter.DbType.Money, 0, model.PayoutValue);
return(Convert.ToInt32(DbConnection.GetScalarValue(CommandType.StoredProcedure, query, ObjParam)));
}
public async Task OnGetAsync()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var role = new Role
{
Id = Guid.NewGuid(),
RoleClaims = new List <RoleClaim>
{
new RoleClaim(),
new RoleClaim(),
new RoleClaim()
}
};
using (var context = new OidcDbContext(options))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
ClaimsModel model;
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
model = new ClaimsModel(_roleManager.Object);
get = await model.OnGetAsync(role.Id).ConfigureAwait(false);
}
// Assert
Assert.NotNull(model.Role);
Assert.Equal(role.Id, model.Role.Id);
var claims = Assert.IsAssignableFrom <IEnumerable <RoleClaim> >(model.Claims);
Assert.Equal(role.RoleClaims.Count, claims.Count());
Assert.IsType <PageResult>(get);
}
public async Task OnGetAsync()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var client = new Client
{
Id = Random.Next(),
Claims = new List <ClientClaim>
{
new ClientClaim(),
new ClientClaim(),
new ClientClaim()
}
};
ClaimsModel model;
IActionResult get;
using (var context = new OidcDbContext(options))
{
context.Add(client);
await context.SaveChangesAsync().ConfigureAwait(false);
}
// Act
using (var context = new OidcDbContext(options))
{
model = new ClaimsModel(context);
get = await model.OnGetAsync(client.Id).ConfigureAwait(false);
}
// Assert
Assert.NotNull(model.Client);
Assert.Equal(client.Id, model.Client.Id);
var claims = Assert.IsAssignableFrom <IEnumerable <ClientClaim> >(model.Claims);
Assert.Equal(client.Claims.Count, claims.Count());
Assert.IsType <PageResult>(get);
}
public async Task OnGetAsync_InvalidId()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync_InvalidId)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var role = new Role
{
Id = Guid.NewGuid(),
RoleClaims = new List <RoleClaim>
{
new RoleClaim(),
new RoleClaim(),
new RoleClaim()
}
};
using (var context = new OidcDbContext(options))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
ClaimsModel model;
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
model = new ClaimsModel(_roleManager.Object);
get = await model.OnGetAsync(Guid.Empty).ConfigureAwait(false);
}
// Assert
Assert.Null(model.Role);
Assert.Null(model.Claims);
Assert.IsType <NotFoundResult>(get);
}
public async Task OnGetAsync_InvalidModel()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnGetAsync_InvalidModel)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
ClaimsModel model;
IActionResult get;
// Act
using (var context = new OidcDbContext(options))
{
model = new ClaimsModel(context);
get = await model.OnGetAsync(Random.Next()).ConfigureAwait(false);
}
// Assert
Assert.Null(model.Client);
Assert.Null(model.Claims);
Assert.IsType <NotFoundResult>(get);
}
public int GetTotalClaims(DateTime?From, DateTime?To, string ssn)
{
HttpResponseMessage response = client.GetAsync(string.Format("https://arionapi-sandbox.azure-api.net/claims/v1/claims?page={0}&perPage={1}&claimantKennitala={2}&dateFrom={3}&dateTo{4}", "1", "1500", ssn, "2013-01-01", "2019-01-01")).Result;
var claims = new ClaimsModel();
if (response.IsSuccessStatusCode)
{
var responseContent = response.Content.ReadAsStringAsync().Result;
claims = JsonConvert.DeserializeObject <ClaimsModel>(responseContent);
if (claims == null)
{
return(0);
}
int sum = 0;
foreach (var claim in claims.claim)
{
sum += Convert.ToInt32(claim.amount);
}
return(sum);
}
return(0);
}
public async Task OnPostAsync_InvalidModel()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_InvalidModel)}";
var options = new DbContextOptionsBuilder <IdentityServerDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var role = new Role {
Id = Guid.NewGuid()
};
var id = Guid.NewGuid();
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult post;
// Act
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
var model = new ClaimsModel(_roleManager.Object)
{
Role = new Role {
Id = id
}
};
post = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_roleManager.Verify(x => x.UpdateAsync(It.IsAny <Role>()), Times.Never);
Assert.IsType <PageResult>(post);
}
public async Task OnPostAsync_InvalidModel()
{
// Arrange
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync_InvalidModel)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var user = new User {
Id = Guid.NewGuid()
};
var id = Guid.NewGuid();
using (var context = new OidcDbContext(options))
{
context.Add(user);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult post;
// Act
using (var context = new OidcDbContext(options))
{
_userManager.Setup(x => x.Users).Returns(context.Users);
var model = new ClaimsModel(_userManager.Object)
{
UserModel = new User {
Id = id
}
};
post = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_userManager.Verify(x => x.UpdateAsync(It.IsAny <User>()), Times.Never);
Assert.IsType <PageResult>(post);
}
public async Task OnPostAsync()
{
// Arrange
const string originalRoleClaim2Type = "Claim 2 Type";
const string newRoleClaim2Type = "New Claim Type";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <IdentityServerDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var roleClaim1 = new RoleClaim
{
ClaimType = "Claim 1 Type",
ClaimValue = "Claim 1 Value"
};
var roleClaim2 = new RoleClaim
{
ClaimType = originalRoleClaim2Type,
ClaimValue = "Claim 2 Value"
};
var roleClaim3 = new RoleClaim
{
ClaimType = "Claim 3 Type",
ClaimValue = "Claim 3 Value"
};
var roleClaim4 = new RoleClaim
{
ClaimType = "Claim 4 Type",
ClaimValue = "Claim 4 Value"
};
var role = new Role
{
Name = "Role Name"
};
role.RoleClaims.Add(roleClaim1);
role.RoleClaims.Add(roleClaim2);
role.RoleClaims.Add(roleClaim3);
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
context.Add(role);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult post;
// Act
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
_roleManager.Setup(x => x.Roles).Returns(context.Roles);
var model = new ClaimsModel(_roleManager.Object)
{
Role = role
};
model.Role.RoleClaims.Single(x => x.ClaimType.Equals(roleClaim2.ClaimType)).ClaimType = newRoleClaim2Type;
model.Role.RoleClaims.Remove(roleClaim3);
model.Role.RoleClaims.Add(roleClaim4);
post = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_roleManager.Verify(x => x.RemoveClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(roleClaim1.ClaimType) && y.Value.Equals(roleClaim1.ClaimValue))),
Times.Never);
_roleManager.Verify(x => x.AddClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(roleClaim1.ClaimType) && y.Value.Equals(roleClaim1.ClaimValue))),
Times.Never);
_roleManager.Verify(x => x.RemoveClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(originalRoleClaim2Type) && y.Value.Equals(roleClaim2.ClaimValue))),
Times.Once);
_roleManager.Verify(x => x.AddClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(newRoleClaim2Type) && y.Value.Equals(roleClaim2.ClaimValue))),
Times.Once);
_roleManager.Verify(
x => x.AddClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(roleClaim4.ClaimType) && y.Value.Equals(roleClaim4.ClaimValue))),
Times.Once);
_roleManager.Verify(
x => x.RemoveClaimAsync(
It.Is <Role>(y => y.Id.Equals(role.Id)),
It.Is <Claim>(y => y.Type.Equals(roleClaim3.ClaimType) && y.Value.Equals(roleClaim3.ClaimValue))),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Role.Id), key);
Assert.Equal(role.Id, value);
});
}
public static int SaveClaims(ClaimsModel model)
{
return(ClaimsDAL.SaveClaims(model));
}
public List <ClaimOutput> GetClaims(ClaimsModel model)
{
string sSQL = @"exec uspAPIGetClaims @ClaimAdminCode,@StartDate,@EndDate,@DateProcessedFrom,@DateProcessedTo,@ClaimStatus";
DataHelper helper = new DataHelper(_configuration);
int? claimStatus = null;
if (model.status_claim != 0)
{
claimStatus = (int)model.status_claim;
}
SqlParameter[] sqlParameters =
{
new SqlParameter("@ClaimAdminCode", model.claim_administrator_code),
new SqlParameter("@StartDate", SqlDbType.DateTime)
{
Value = (model.visit_date_from != null)?model.visit_date_from:(object)DBNull.Value
},
new SqlParameter("@EndDate", SqlDbType.DateTime)
{
Value = (model.visit_date_to != null)?model.visit_date_to:(object)DBNull.Value
},
new SqlParameter("@DateProcessedFrom", SqlDbType.DateTime)
{
Value = (model.processed_date_from != null)?model.processed_date_from:(object)DBNull.Value
},
new SqlParameter("@DateProcessedTo", SqlDbType.DateTime)
{
Value = (model.processed_date_to != null)?model.processed_date_to:(object)DBNull.Value
},
new SqlParameter("@ClaimStatus", SqlDbType.Int)
{
Value = (claimStatus != null)?claimStatus:(object)DBNull.Value
},
};
var response = helper.GetDataSet(sSQL, sqlParameters, CommandType.Text);
DataTable responseItems = response.Tables[0];
DataTable responseServices = response.Tables[1];
DataTable responseClaims = response.Tables[2];
Dictionary <string, ClaimOutput> admin_claims = (from DataRow dr in responseClaims.Rows
select new ClaimOutput()
{
claim_uuid = dr["claim_uuid"].ToStringWithDBNull(),
health_facility_code = dr["health_facility_code"].ToStringWithDBNull(),
health_facility_name = dr["health_facility_name"].ToStringWithDBNull(),
insurance_number = dr["insurance_number"].ToStringWithDBNull(),
patient_name = dr["patient_name"].ToStringWithDBNull(),
main_dg = dr["main_dg"].ToStringWithDBNull(),
claim_number = dr["claim_number"].ToStringWithDBNull(),
date_claimed = dr["date_claimed"].ToString().ToNullableDatetime(),
visit_date_from = dr["visit_date_from"].ToString().ToNullableDatetime(),
visit_type = dr["visit_type"].ToStringWithDBNull(),
claim_status = dr["claim_status"].ToStringWithDBNull(),
sec_dg_1 = dr["sec_dg_1"].ToStringWithDBNull(),
sec_dg_2 = dr["sec_dg_2"].ToStringWithDBNull(),
sec_dg_3 = dr["sec_dg_3"].ToStringWithDBNull(),
sec_dg_4 = dr["sec_dg_4"].ToStringWithDBNull(),
visit_date_to = dr["visit_date_to"].ToString().ToNullableDatetime(),
claimed = dr["claimed"].ToString().ParseNullableDecimal(),
approved = dr["approved"].ToString().ParseNullableDecimal(),
adjusted = dr["adjusted"].ToString().ParseNullableDecimal(),
explanation = dr["explanation"].ToStringWithDBNull(),
adjustment = dr["adjustment"].ToStringWithDBNull(),
guarantee_number = dr["guarantee_number"].ToStringWithDBNull(),
services = new List <ClaimService>(),
items = new List <ClaimItem>()
}).ToList().ToDictionary(x => x.claim_uuid, x => x, StringComparer.OrdinalIgnoreCase);
(from DataRow dr in responseItems.Rows
select new ClaimItem()
{
claim_uuid = dr["claim_uuid"].ToStringWithDBNull(),
claim_number = dr["claim_number"].ToStringWithDBNull(),
item = dr["item"].ToStringWithDBNull(),
item_code = dr["item_code"].ToStringWithDBNull(),
item_qty = dr["item_qty"].ToString().ParseNullableDecimal(),
item_price = dr["item_price"].ToString().ParseNullableDecimal(),
item_adjusted_qty = dr["item_adjusted_qty"].ToString().ParseNullableDecimal(),
item_adjusted_price = dr["item_adjusted_price"].ToString().ParseNullableDecimal(),
item_explination = dr["item_explination"].ToStringWithDBNull(),
item_justificaion = dr["item_justificaion"].ToStringWithDBNull(),
item_valuated = dr["item_valuated"].ToString().ParseNullableDecimal(),
item_result = dr["item_result"].ToStringWithDBNull(),
}).ToList().ForEach((x) => { if (admin_claims.ContainsKey(x.claim_uuid))
{
admin_claims[x.claim_uuid].items.Add(x);
}
});
(from DataRow dr in responseServices.Rows
select new ClaimService()
{
claim_uuid = dr["claim_uuid"].ToStringWithDBNull(),
claim_number = dr["claim_number"].ToStringWithDBNull(),
service = dr["service"].ToStringWithDBNull(),
service_code = dr["service_code"].ToStringWithDBNull(),
service_qty = dr["service_qty"].ToString().ParseNullableDecimal(),
service_price = dr["service_price"].ToString().ParseNullableDecimal(),
service_adjusted_qty = dr["service_adjusted_qty"].ToString().ParseNullableDecimal(),
service_adjusted_price = dr["service_adjusted_price"].ToString().ParseNullableDecimal(),
service_explination = dr["service_explination"].ToStringWithDBNull(),
service_justificaion = dr["service_justificaion"].ToStringWithDBNull(),
service_valuated = dr["service_valuated"].ToString().ParseNullableDecimal(),
service_result = dr["service_result"].ToStringWithDBNull(),
}).ToList().ForEach((x) => { if (admin_claims.ContainsKey(x.claim_uuid))
{
admin_claims[x.claim_uuid].services.Add(x);
}
});
List <ClaimOutput> output = admin_claims.Values.ToList();
return(output);
}
public async Task OnPostAsync()
{
// Arrange
const string originalUserClaim2Type = "Claim 2 Type";
const string newUserClaim2Type = "New Claim Type";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <OidcDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var userClaim1 = new UserClaim
{
ClaimType = "Claim 1 Type",
ClaimValue = "Claim 1 Value"
};
var userClaim2 = new UserClaim
{
ClaimType = originalUserClaim2Type,
ClaimValue = "Claim 2 Value"
};
var userClaim3 = new UserClaim
{
ClaimType = "Claim 3 Type",
ClaimValue = "Claim 3 Value"
};
var userClaim4 = new UserClaim
{
ClaimType = "Claim 4 Type",
ClaimValue = "Claim 4 Value"
};
var user = new User
{
Email = "Email",
Claims = new List <UserClaim>
{
userClaim1,
userClaim2,
userClaim3
}
};
using (var context = new OidcDbContext(options))
{
context.Add(user);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult post;
// Act
using (var context = new OidcDbContext(options))
{
_userManager.Setup(x => x.Users).Returns(context.Users);
var model = new ClaimsModel(_userManager.Object)
{
UserModel = user
};
model.UserModel.Claims.Single(x => x.ClaimType.Equals(userClaim2.ClaimType)).ClaimType = newUserClaim2Type;
model.UserModel.Claims.Remove(userClaim3);
model.UserModel.Claims.Add(userClaim4);
post = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_userManager.Verify(x => x.ReplaceClaimAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <Claim>(y => y.Type.Equals(userClaim1.ClaimType) && y.Value.Equals(userClaim1.ClaimValue)),
It.IsAny <Claim>()),
Times.Never);
_userManager.Verify(x => x.ReplaceClaimAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <Claim>(y => y.Type.Equals(originalUserClaim2Type) && y.Value.Equals(userClaim2.ClaimValue)),
It.Is <Claim>(y => y.Type.Equals(newUserClaim2Type) && y.Value.Equals(userClaim2.ClaimValue))),
Times.Once);
_userManager.Verify(
x => x.AddClaimsAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <IEnumerable <Claim> >(y => y.SingleOrDefault(z => z.Type.Equals(userClaim4.ClaimType) && z.Value.Equals(userClaim4.ClaimValue)) != null)),
Times.Once);
_userManager.Verify(
x => x.RemoveClaimsAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <IEnumerable <Claim> >(y => y.SingleOrDefault(z => z.Type.Equals(userClaim3.ClaimType) && z.Value.Equals(userClaim3.ClaimValue)) != null)),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(User.Id), key);
Assert.Equal(user.Id, value);
});
}