public ClaimData Execute(RegisterClaimRequest request)
{
if (request.ClaimData == null)
{
throw new RegisterClaimException("ClaimData is null. Please, check ClaimData.");
}
if (request.ClaimerId == Guid.Empty)
{
throw new RegisterClaimException("ClaimData does not have ClaimerId. ClaimerId is necessary.");
}
ClaimData claimData = request.ClaimData;
using (var repository = _repositoryFactory.MakeRepository())
{
var claimerData = repository.Find <Person>(request.ClaimerId);
if (claimerData == null)
{
throw new RegisterClaimException(string.Format("There is not a person with Id = {0}", request.ClaimData.PersonId));
}
claimData.StateId = ClaimState.Registered;
claimerData.Claims.Add(claimData);
repository.Save();
}
return(claimData);
}
// Skip cube and go for list with xyz values and look for matches
public override string executeA(string[] inputs)
{
Dictionary <string, int> overlapCnt = new Dictionary <string, int>();
foreach (var input in inputs)
{
//Parse input data
ClaimData claim = parseClaim(input);
//check overlap
for (int y = 0; y < claim.height; y++)
{
for (int x = 0; x < claim.length; x++)
{
var key = $"X{claim.x+x}Y{claim.y+y}";
if (overlapCnt.ContainsKey(key))
{
overlapCnt[key]++;
}
else
{
overlapCnt.Add(key, 1);
}
}
}
}
return(overlapCnt.Values.Where(x => x > 1).Count().ToString());
}
public void ShouldReturnRegisteredClaim()
{
registerClaim = new SqlRegisterClaim(new FakePersonsRepositoryFactory());
var claimerId = Guid.Parse("931B4569-F92D-E611-80B3-3C4A92F56376");
var claimData = new ClaimData()
{
Inn = "234123219879",
RegAddress = "г. Уфа",
PostAddress = "Ufa",
Job = "ООО Башнефть",
JobSphere = "Нефть",
Position = "генеральный директор",
FamilyIncome = "500000",
PersonalIncome = "400000",
Ownership = "Дом",
Email = "*****@*****.**",
Phone = "9177777777",
DateTime = new DateTime(2016, 07, 28, 17, 35, 59),
CategoryId = 1,
ProgramId = 1
};
var claimDateProvider = new NowClaimDateProvider();
var request = new RegisterClaimRequest(claimerId, claimData, claimDateProvider);
var claim = registerClaim.Execute(request);
Assert.That(claim, Is.InstanceOf <ClaimData>());
Assert.That(claim.StateId, Is.EqualTo(ClaimState.Registered));
}
public void ShouldThrowExceptionIfThereIsNoPersonWithThatPersonId()
{
var repositoryFactory = new EveryTimeReturnsNullRepositoryFactory();
registerClaim = new SqlRegisterClaim(repositoryFactory);
var claimData = new ClaimData()
{
Inn = "234123219879",
RegAddress = "г. Уфа",
PostAddress = "Ufa",
Job = "ООО Башнефть",
JobSphere = "Нефть",
Position = "генеральный директор",
FamilyIncome = "500000",
PersonalIncome = "400000",
Ownership = "Дом",
Email = "*****@*****.**",
Phone = "9177777777",
DateTime = new DateTime(2016, 07, 28, 17, 35, 59),
CategoryId = 1,
ProgramId = 1
};
var claimDateProvider = new NowClaimDateProvider();
var request = new RegisterClaimRequest(Guid.NewGuid(), claimData, claimDateProvider);
Assert.That(delegate
{
registerClaim.Execute(request);
}, Throws.TypeOf <RegisterClaimException>());
}
public ClaimViewModel Present(ClaimData claimData)
{
var viewModel = new ClaimViewModel()
{
Id = claimData.Id,
Inn = claimData.Inn,
RegAddress = claimData.RegAddress,
PostAddress = claimData.PostAddress,
Job = claimData.Job,
JobSphere = claimData.JobSphere,
Position = claimData.Position,
FamilyIncome = claimData.FamilyIncome,
PersonalIncome = claimData.PersonalIncome,
Ownership = claimData.Ownership,
Email = claimData.Email,
Phone = claimData.Phone,
DateTime = claimData.DateTime
};
//if (_claimData.DateTime.HasValue)
// viewModel.DateTime = _cla
return(viewModel);
}
private RegisterClaimRequest CreateRequest(CreateClaimViewModel model)
{
if (!model.PersonId.HasValue)
{
throw new RegisterClaimException("There is no personId. PersonId is required");
}
var claimData = new ClaimData
{
Inn = model.Inn,
RegAddress = model.RegAddress,
PostAddress = model.PostAddress,
Job = model.Job,
JobSphere = model.JobSphere,
Position = model.Position,
FamilyIncome = model.FamilyIncome,
PersonalIncome = model.PersonalIncome,
Ownership = model.Ownership,
Email = model.Email,
Phone = model.Phone,
CategoryId = 1,
ProgramId = 1
};
var request = new RegisterClaimRequest(model.PersonId.Value, claimData, _claimDateProvider);
return(request);
}
public void ThenISeeClaimsDisplayOnTheListWithValidDataInOrder()
{
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters.Add("CaseId", Convert.ToString(CaseDetailSteps.GetCaseIdFromCaseNumber(ScenarioContext.Current.Get <string>("Case Number"))));
parameters.Add("OfficeId", Convert.ToString(CommonDBSteps.GetConfigOfficeId()));
DataRowCollection expected = ExecuteQueryOnDB(Properties.Resources.GetClaimsDetailsByCaseId, parameters);
IEnumerator <ClaimData> actualClaims = claimsTab.GetFirstNClaims(expected.Count).GetEnumerator();
actualClaims.MoveNext();
foreach (DataRow claimFromDB in expected)
{
ClaimData claim = actualClaims.Current;
claim.ClaimNumber.Trim().Should().Be(claimFromDB.Field <string>("ClaimNumber").Trim(), "[" + claim.Id + "] Claim Number is correct");
claim.CreditorName.Should().BeEquivalentTo(claimFromDB.Field <string>("CreditorName").TrimEnd(), "[" + claim.Id + "] Claim Creditor Name is correct");
string status = claimFromDB.Field <string>("Status");
claim.Status.Should().Be(status.ToUpper(), "[" + claim.Id + "] Claim Status is " + status);
string statusColor = this.GetStatusColor(status);
claim.CornerTagColor.Should().Be(statusColor, "[" + claim.Id + "] Claim Corner Tag Color is " + statusColor);
string cornerTagLetter = this.getCornerTagLetter(status);
claim.CornerTagLetter.Should().Be(cornerTagLetter, "[" + claim.Id + "] Claim Corner Tag Letter is " + cornerTagLetter);
claim.StatusColor.Should().Be(statusColor, "[" + claim.Id + "] Claim Status Color is " + statusColor);
string claimClass = claimFromDB.Field <string>("ClaimClass");
claim.Class.Should().Be(claimClass, "[" + claim.Id + "] Claim Class is " + claimClass);
string classColor = this.GetCircleClassColor(claimClass);
claim.CircleIndicatorColor.Should().Be(classColor, "[" + claim.Id + "] Claim Circle Ind. Color is " + classColor);
claim.Category.Should().Be(claimFromDB.Field <string>("Category"), "[" + claim.Id + "] Claim Category is correct");
claim.Code.Should().Be(claimFromDB.Field <string>("Code"), "[" + claim.Id + "] Claim CODE is correct");
claim.PaySequence.Should().Be("" + claimFromDB.Field <int>("PaySequence"), "[" + claim.Id + "] Claim Pay Sequence is correct");
string expClaimedStr = this.GetClaimExpectedAmount(claimFromDB.Field <Decimal>("ClaimedAmount"));
claim.Claimed.Replace(",", "").Should().Be(expClaimedStr, "[" + claim.Id + "] Claim Claimed amount is correct");
string expAllowedStr = this.GetClaimExpectedAmount(claimFromDB.Field <Decimal>("AllowedAmount"));
claim.Allowed.Replace(",", "").Should().Be(expAllowedStr, "[" + claim.Id + "] Claim Allowed amount is correct");
string expPaidStr = this.GetClaimExpectedAmount(claimFromDB.Field <Decimal>("PaidAmount"));
claim.Paid.Replace(",", "").Should().Be(expPaidStr, "[" + claim.Id + "] Claim Paid amount is correct");
string expReservedStr = this.GetClaimExpectedAmount(claimFromDB.Field <Decimal>("ReservedAmount"));
claim.Reserved.Replace(",", "").Should().Be(expReservedStr, "[" + claim.Id + "] Claim Reserved amount is correct");
string expInterestStr = this.GetClaimExpectedAmount(claimFromDB.Field <Decimal>("Interest"));
claim.Interest.Replace(",", "").Should().Be(expInterestStr, "[" + claim.Id + "] Claim Interest amount is correct");
string expBalanceStr = this.GetClaimExpectedAmount(claimFromDB.Field <Decimal>("BalanceAmount"));
claim.Balance.Replace(",", "").Should().Be(expBalanceStr, "[" + claim.Id + "] Claim Balance amount is correct");
actualClaims.MoveNext();
}
}
public override string executeB(string[] inputs)
{
Dictionary <string, int> overlapCnt = new Dictionary <string, int>();
List <ClaimData> claims = new List <ClaimData>();
foreach (var input in inputs)
{
//Parse input data
ClaimData claim = parseClaim(input);
claims.Add(claim);
//check overlap
for (int y = 0; y < claim.height; y++)
{
for (int x = 0; x < claim.length; x++)
{
var key = $"X{claim.x+x}Y{claim.y+y}";
if (overlapCnt.ContainsKey(key))
{
overlapCnt[key]++;
}
else
{
overlapCnt.Add(key, 1);
}
}
}
}
// search for the single claim that doesn't overlap
bool found;
foreach (var claim in claims)
{
found = true;
for (int y = 0; y < claim.height; y++)
{
for (int x = 0; x < claim.length; x++)
{
var key = $"X{claim.x+x}Y{claim.y+y}";
if (overlapCnt[key] != 1)
{
found = false;
break;
}
}
if (!found)
{
break;
}
}
if (found)
{
return(claim.z.ToString());
}
}
return("claim not found");
}
public void SetUp()
{
var claimData = new ClaimData
{
ProgramId = 1,
CategoryId = 1
};
claim = Claim.Make(claimData);
}
public void ShouldCanMakeClaim()
{
var claimData = new ClaimData
{
ProgramId = 1,
CategoryId = 1
};
var claim = claimer.MakeClaim(claimData);
Assert.That(claim, Is.Not.Null);
}
//[DeploymentItem("MedWorth.ContractManagement.BusinessLogic.dll")]
public void UpdateClaimChargeDataTest()
{
MatchServiceType_Accessor target = new MatchServiceType_Accessor();
Contracts contract = null;
ClaimData claimData = null;
ClaimData expected = null;
ClaimData actual;
actual = target.UpdateClaimChargeData(contract, claimData);
Assert.AreEqual(expected, actual);
//Assert.Inconclusive("Verify the correctness of this test method.");
}
//[DeploymentItem("MedWorth.ContractManagement.BusinessLogic.dll")]
public void IsContractServiceTypeFiltersAreValidORNotTest()
{
MatchServiceType_Accessor target = new MatchServiceType_Accessor();
ContractServiceTypes contractServiceTypes = null;
ClaimCode code = null;
List <ClaimFieldDocs> docs = null;
ClaimData claimData = null;
bool expected = false;
bool actual = target.IsContractServiceTypeFiltersAreValidORNot(contractServiceTypes, code, docs, claimData);
Assert.AreEqual(expected, actual);
//Assert.Inconclusive("Verify the correctness of this test method.");
}
//[DeploymentItem("MedWorth.ContractManagement.BusinessLogic.dll")]
public void IsTableSelectionAvailableTest()
{
MatchServiceType_Accessor target = new MatchServiceType_Accessor();
ContractServiceLineTableSelection contractServiceLineTableSelection = null;
ContractServiceTypes contractServiceTypes = null;
ClaimData claimData = null;
List <ClaimFieldDocs> docs = null;
bool expected = false;
bool actual = target.IsTableSelectionAvailable(contractServiceLineTableSelection, contractServiceTypes, claimData, docs);
Assert.AreEqual(expected, actual);
//Assert.Inconclusive("Verify the correctness of this test method.");
}
public IActionResult ObtainPendAdvice([FromBody] ClaimData claim)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
//For simplicity, the entire client logic is implemented inside the controller
var modelInput = _mapper.Map <ModelInput>(claim);
var modelOutput = PendPredictor.PredictEx(modelInput);
var adviceData = _mapper.Map <AdviceData>(modelOutput);
adviceData.ClaimID = claim.ClaimID;
return(Ok(adviceData));
}
public static ClaimData getClaimData(ClaimsPrincipal principal)
{
ClaimData data = null;
if (principal.Claims.Count() > 0)
{
data = new ClaimData
{
Id = Convert.ToInt32(principal.FindFirst(ClaimTypes.Sid).Value),
UserName = principal.FindFirst(ClaimTypes.Name).Value,
Role = principal.FindFirst(ClaimTypes.Role).Value
};
}
return(data);
}
private ClaimData parseClaim(string input)
{
ClaimData claim = new ClaimData();
var tmp = input.Split('@');
claim.z = int.Parse(tmp[0].Trim().Remove(0, 1));
tmp = tmp[1].Split(':');
var cord = tmp[0].Split(',');
var sides = tmp[1].Split('x');
claim.x = int.Parse(cord[0].Trim());
claim.y = int.Parse(cord[1].Trim());
claim.length = int.Parse(sides[0].Trim());
claim.height = int.Parse(sides[1].Trim());
return(claim);
}
public bool IsValid(ClaimData claimData)
{
return(!string.IsNullOrWhiteSpace(claimData.Inn) &&
!string.IsNullOrWhiteSpace(claimData.RegAddress) &&
!string.IsNullOrWhiteSpace(claimData.PostAddress) &&
!string.IsNullOrWhiteSpace(claimData.Job) &&
!string.IsNullOrWhiteSpace(claimData.JobSphere) &&
!string.IsNullOrWhiteSpace(claimData.Position) &&
!string.IsNullOrWhiteSpace(claimData.FamilyIncome) &&
!string.IsNullOrWhiteSpace(claimData.PersonalIncome) &&
!string.IsNullOrWhiteSpace(claimData.Ownership) &&
!string.IsNullOrWhiteSpace(claimData.Phone) &&
claimData.CategoryId != 0 &&
claimData.ProgramId != 0
);
}
public void ClaimDataRepo_AddClaimToQueue_ShouldAdd()
{
//Arrange
ClaimData whip = new ClaimData();
ClaimData suv = new ClaimData();
ClaimData truck = new ClaimData();
claimRepo.AddClaimToQueue(whip);
claimRepo.AddClaimToQueue(suv);
claimRepo.AddClaimToQueue(truck);
//Act
int actual = claimRepo.GetClaimInfo().Count;
int expected = 3;
//Assert
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Estimats a claimData item from a given mapping and an original claim
/// </summary>
/// <param name="map">the mapping instruction for estimating a new claim</param>
/// <param name="original">the original claim-value</param>
/// <returns>a new claim that must be added to the currently logged on user</returns>
private ClaimData TryGetClaim(AuthenticationClaimMapping map, ClaimData original)
{
try
{
return(new ClaimData
{
Type = original.FormatText(map.OutgoingClaimName),
ValueType = !string.IsNullOrEmpty(map.OutgoingValueType) ? original.FormatText(map.OutgoingValueType) : "",
Issuer = !string.IsNullOrEmpty(map.OutgoingIssuer) ? original.FormatText(map.OutgoingIssuer) : "",
OriginalIssuer = !string.IsNullOrEmpty(map.OutgoingOriginalIssuer) ? original.FormatText(map.OutgoingOriginalIssuer) : "",
Value = !string.IsNullOrEmpty(map.OutgoingClaimValue) ? original.FormatText(map.OutgoingClaimValue) : ""
});
}
catch
{
}
return(null);
}
public static AuthorizationOptions GetAuthorizationOptions(AuthorizationOptions options)
{
try
{
var requiresAdministrativePrivilegesClaims = new List <ClaimData>();
var claim = new ClaimData
{
ClaimType = "Role",
ClaimValue = "Admin"
};
requiresAdministrativePrivilegesClaims.Add(claim);
options.AddPolicy("RequiresAdministrativePrivileges", policy => policy.Requirements.Add(new RequiredClaims(requiresAdministrativePrivilegesClaims.ToArray())));
return(options);
}
catch (Exception ex)
{
Logger.LogError("Error in GetAuthorizationOptions", ex);
throw ex;
}
}
public void ShouldPresentClaim()
{
var claimData = new ClaimData()
{
Inn = "234123219879",
RegAddress = "г. Уфа",
PostAddress = "Ufa",
Job = "ООО Башнефть",
JobSphere = "Нефть",
Position = "генеральный директор",
FamilyIncome = "500000",
PersonalIncome = "400000",
Ownership = "Дом",
Email = "*****@*****.**",
Phone = "9177777777",
DateTime = new DateTime(2016, 07, 28, 17, 35, 59),
CategoryId = 1,
ProgramId = 1
};
claimPresenter = new ClaimPresenter();
var viewModel = claimPresenter.Present(claimData);
Assert.That(viewModel, Is.InstanceOf <ClaimViewModel>());
Assert.That(viewModel.Inn, Is.EqualTo("234123219879"));
Assert.That(viewModel.RegAddress, Is.EqualTo("г. Уфа"));
Assert.That(viewModel.PostAddress, Is.EqualTo("Ufa"));
Assert.That(viewModel.Job, Is.EqualTo("ООО Башнефть"));
Assert.That(viewModel.JobSphere, Is.EqualTo("Нефть"));
Assert.That(viewModel.Position, Is.EqualTo("генеральный директор"));
Assert.That(viewModel.FamilyIncome, Is.EqualTo("500000"));
Assert.That(viewModel.PersonalIncome, Is.EqualTo("400000"));
Assert.That(viewModel.Ownership, Is.EqualTo("Дом"));
Assert.That(viewModel.Email, Is.EqualTo("*****@*****.**"));
Assert.That(viewModel.Phone, Is.EqualTo("9177777777"));
Assert.That(viewModel.DateTime, Is.EqualTo(new DateTime(2016, 07, 28, 17, 35, 59)));
//Assert.That(viewModel.CategoryId, Is.EqualTo(1));
//Assert.That(viewModel.ProgramId, Is.EqualTo(1));
}
public static ClaimData GetUserData()
{
string key = "PUNNEL:ClaimData";
ClaimData res = (ClaimData)HttpContext.Current.Items[key];
if (res != null)
{
return(res);
}
if (res == null)
{
var identity = (ClaimsIdentity)HttpContext.Current.User.Identity;
if (identity.IsAuthenticated == true)
{
Claim item = identity.Claims.FirstOrDefault(w => w.Type == ClaimTypes.UserData);
if (item != null)
{
res = item.Value.FromJson <ClaimData>();
}
}
}
if (res != null)
{
// reload data from profile
IUow uow = Core.Entities.ObjectFactory.GetInstance <IUow>();
var profile = uow.UserProfile.Get(res.UserId);
if (profile == null)
{
return(res);
}
res.Level = profile.Level;
res.Role = profile.Role;
res.Email = profile.Email;
}
HttpContext.Current.Items[key] = res;
return(res);
}
public void ShouldBeInvalidIfNoPostAddress()
{
var claimData = new ClaimData()
{
Inn = "234123219879",
RegAddress = "г. Уфа",
//PostAddress = "Ufa",
Job = "ООО Башнефть",
JobSphere = "Нефть",
Position = "генеральный директор",
FamilyIncome = "500000",
PersonalIncome = "400000",
Ownership = "Дом",
Email = "*****@*****.**",
Phone = "9177777777",
DateTime = new DateTime(2016, 07, 28, 17, 35, 59),
CategoryId = 1,
ProgramId = 1
};
var result = validator.IsValid(claimData);
Assert.That(result, Is.False);
}
public RegisterClaimRequest(Guid claimerId, ClaimData claimData, ClaimDateProvider claimDateProvider)
{
ClaimerId = claimerId;
ClaimData = claimData;
_claimDateProvider = claimDateProvider;
}
//public static Claim Make(Guid id, ClaimData claimData)
//{
// var claimDataValidator = new ClaimDataValidator();
// if (!claimDataValidator.IsValid(claimData))
// throw new InvalidClaimDataException();
// return new Claim(id, claimData);
//}
//private static bool IsValid(ClaimData claimData)
//{
// return claimData.ProgramId != 0 && claimData.CategoryId != 0;
//}
public Claim(Guid claimerId, ClaimData claimData)
{
data = claimData;
data.PersonId = claimerId;
}
public void Validate(ClaimData claimData)
{
throw new InvalidClaimDataException();
}
public User GetUser(Guid userId)
{
try
{
var user = new User();
user.UserId = userId;
var activeDirectoryAccessorFactory = new ActiveDirectoryAccessors.AccessorFactory();
IGraphAccessor graphAccessor = activeDirectoryAccessorFactory.CreateAccessor <IGraphAccessor>();
var userInformation = graphAccessor.GetUserById(userId.ToString());
user.DisplayName = userInformation.DisplayName;
user.EmailAddress = userInformation.EmailAddress;
user.FirstName = userInformation.FirstName;
user.LastName = userInformation.LastName;
//Enigne that takes a user and spits out claims
var databaseAccessorFactory = new DatabaseAccessors.AccessorFactory();
IApplicationsAccessor applicationAccessor = databaseAccessorFactory.CreateAccessor <IApplicationsAccessor>();
IClaimsAccessor claimsAccessor = databaseAccessorFactory.CreateAccessor <IClaimsAccessor>();
IUserClaimsAccessor userClaimsAccessor = databaseAccessorFactory.CreateAccessor <IUserClaimsAccessor>();
IMembershipsAccessor membershipsAccessor = databaseAccessorFactory.CreateAccessor <IMembershipsAccessor>();
var userClaims = userClaimsAccessor.FindAllUserClaims(user.UserId);
var userApplications = membershipsAccessor.FindAllUserApplications(user.UserId);
var applicationClaims = new List <ApplicationClaims>();
foreach (var userApplication in userApplications)
{
var application = applicationAccessor.Find(userApplication.ApplicationId);
var applicationClaim = new ApplicationClaims
{
ApplicationName = application.Name,
Claims = new ClaimData[0]
};
applicationClaims.Add(applicationClaim);
}
foreach (var userClaim in userClaims)
{
var userClaimData = claimsAccessor.Find(userClaim.ClaimId);
var application = applicationAccessor.Find(userClaimData.ApplicationId);
var applicationClaim = applicationClaims.Where(app => app.ApplicationName == application.Name).FirstOrDefault();
var claimData = new ClaimData
{
ClaimType = userClaimData.ClaimType,
ClaimValue = userClaimData.ClaimValue
};
var claimDataList = applicationClaim.Claims.ToList();
claimDataList.Add(claimData);
applicationClaim.Claims = claimDataList.ToArray();
}
user.Applications = applicationClaims.ToArray();
return(user);
}
catch (Exception ex)
{
Logger.LogError("Error in GetUser", ex);
return(null);
}
}
public void AddApplicationClaimForUser(Guid applicationId, Guid userId, ClaimData claim)
{
throw new NotImplementedException();
}
public Claim MakeClaim(ClaimData claimData)
{
var claim = new Claim(Id, claimData);
return(claim);
}
