public void AddClaimAllowedGroup()
{
var vm = AddClaimViewModel.Create(Mock.Group, Mock.Player.UserId);
vm.IsAvailable.ShouldBeTrue();
vm.CanSendClaim.ShouldBeTrue();
}
public IActionResult AddClaim(AddClaimViewModel createDTO)
{
List <IFormFile> uploadedFiles = createDTO.FilesUploaded;
if (!ModelState.IsValid)
{
ViewBag.lang = langcode;
createDTO._claimstypes = GetClaimTypesViewModel();
createDTO._bankNames = GetBankViewModel();
createDTO.FilesUploaded = uploadedFiles;
return(View(createDTO));
}
else
{
ViewBag.lang = langcode;
createDTO.NationalId = TempData["NationalId"].ToString();
TempData.Keep("NationalId");
var res = AddClaimRequest(createDTO);
if (res == "true")
{
HttpContext.Session.SetString(SessionShowDialog, "true");
}
else
{
HttpContext.Session.SetString(SessionShowDialog, "false");
}
return(RedirectToAction("ReimbursmentClaims", "Claims", new { lang = "en" }));
}
}
public async Task <string> AddClaimRequest(AddClaimViewModel _claimdetails)
{
RequestCreateDTO reImClaimdetails = null;
string status = "false";
try
{
reImClaimdetails = GetRequestModel(_claimdetails);
HttpMessageHandler handler = new HttpClientHandler();
string url = "https://localhost:44328/api/AddClaimRequest_New";
string cpath = url;
var httpClient = new HttpClient(handler)
{
BaseAddress = new Uri(cpath),
Timeout = new TimeSpan(0, 2, 0)
};
httpClient.DefaultRequestHeaders.Add("ContentType", "application/json");
var content = JsonConvert.SerializeObject(reImClaimdetails);
var httpContent = new StringContent(content, Encoding.UTF8, "application/json");
HttpResponseMessage response = await httpClient.PostAsync(url, httpContent);
if (response.StatusCode == HttpStatusCode.OK)
{
var a = JsonConvert.DeserializeObject <string>(response.Content.ReadAsStringAsync().Result);
status = a;
}
}
catch (Exception ex)
{
throw ex;
}
return(status);
}
public async Task <string> AddClaimReq(AddClaimViewModel _clm)
{
string nationalId = TempData["NationalId"].ToString();
_clm.ClientDTO.IDNumber = nationalId;
return(await _claimsHandler.AddClaimRequest(_clm));
}
public async Task <ActionResult> Add(AddClaimViewModel viewModel)
{
var project = await ProjectRepository.GetProjectAsync(viewModel.ProjectId);
if (project == null)
{
return(HttpNotFound());
}
try
{
await _claimService.AddClaimFromUser(viewModel.ProjectId, viewModel.CharacterGroupId, viewModel.CharacterId, viewModel.ClaimText,
GetCustomFieldValuesFromPost());
return(RedirectToAction(
"SetupProfile",
"Manage",
new { checkContactsMessage = true }));
}
catch (Exception exception)
{
ModelState.AddException(exception);
var source = await ProjectRepository.GetClaimSource(viewModel.ProjectId, viewModel.CharacterGroupId, viewModel.CharacterId).ConfigureAwait(false);
return(View(viewModel.Fill(source, CurrentUserId)));
}
}
public async Task <ActionResult> Add(AddClaimViewModel viewModel)
{
var project = await ProjectRepository.GetProjectAsync(viewModel.ProjectId);
var error = WithEntity(project);
if (error != null)
{
return(error);
}
try
{
await _claimService.AddClaimFromUser(viewModel.ProjectId, viewModel.CharacterGroupId, viewModel.CharacterId,
CurrentUserId, viewModel.ClaimText,
GetCustomFieldValuesFromPost());
return(RedirectToAction(
"SetupProfile",
"Manage",
new { checkContactsMessage = true }));
}
catch (Exception exception)
{
ModelState.AddException(exception);
var source = await GetClaimSource(viewModel.ProjectId, viewModel.CharacterGroupId, viewModel.CharacterId);
//TODO: Отображать ошибки верно
return(View(viewModel.Fill(source, GetCurrentUser())));
}
}
public void CantSendClaimToSameGroup()
{
_ = Mock.CreateClaim(Mock.Group, Mock.Player);
var vm = AddClaimViewModel.Create(Mock.Group, Mock.Player.UserId);
vm.CanSendClaim.ShouldBeFalse();
vm.IsProjectRelatedReason.ShouldBeFalse();
}
public void CantSendClaimIfHasApproved()
{
_ = Mock.CreateApprovedClaim(Mock.Character, Mock.Player);
var vm = AddClaimViewModel.Create(Mock.Group, Mock.Player.UserId);
vm.CanSendClaim.ShouldBeFalse();
vm.IsProjectRelatedReason.ShouldBeFalse();
}
public void AllowSendClaimEvenIfHasAnotherNotApproved()
{
_ = Mock.CreateClaim(Mock.Character, Mock.Player);
var vm = AddClaimViewModel.Create(Mock.Group, Mock.Player.UserId);
vm.CanSendClaim.ShouldBeTrue();
vm.IsProjectRelatedReason.ShouldBeFalse();
vm.ValidationStatus.ShouldContain(AddClaimForbideReasonViewModel.AlredySentNotApprovedClaimToAnotherPlace);
}
public void AllowSendClaimEvenIfHasApprovedAccordingToSettings()
{
Mock.Project.Details.EnableManyCharacters = true;
_ = Mock.CreateApprovedClaim(Mock.Character, Mock.Player);
var vm = AddClaimViewModel.Create(Mock.Group, Mock.Player.UserId);
vm.CanSendClaim.ShouldBeTrue();
vm.IsProjectRelatedReason.ShouldBeFalse();
}
public void CantSendClaimToSameCharacterEvenProjectSettingsAllowsMultiple()
{
Mock.Project.Details.EnableManyCharacters = true;
_ = Mock.CreateClaim(Mock.Character, Mock.Player);
var vm = AddClaimViewModel.Create(Mock.Character, Mock.Player.UserId);
vm.CanSendClaim.ShouldBeFalse();
vm.IsProjectRelatedReason.ShouldBeFalse();
}
public void CantSendClaimToNotAvailCharacter()
{
Mock.Character.IsAcceptingClaims = false;
var vm = AddClaimViewModel.Create(Mock.Character, Mock.Player.UserId);
vm.IsAvailable.ShouldBeFalse();
vm.CanSendClaim.ShouldBeFalse();
vm.IsProjectRelatedReason.ShouldBeFalse();
}
public void CantSendClaimToNotAvailGroup()
{
Mock.Group.HaveDirectSlots = false;
var vm = AddClaimViewModel.Create(Mock.Group, Mock.Player.UserId);
vm.IsAvailable.ShouldBeFalse();
vm.CanSendClaim.ShouldBeFalse();
vm.IsProjectRelatedReason.ShouldBeFalse();
}
public void AllowSendClaimToSameGroupIfProjectSettingsAllows()
{
Mock.Project.Details.EnableManyCharacters = true;
_ = Mock.CreateClaim(Mock.Group, Mock.Player);
var vm = AddClaimViewModel.Create(Mock.Group, Mock.Player.UserId);
vm.CanSendClaim.ShouldBeTrue();
vm.IsProjectRelatedReason.ShouldBeFalse();
}
private RequestCreateDTO GetRequestModel(AddClaimViewModel addClaimViewModel)
{
RequestCreateDTO _clmdet = null;
List <RequestFileDTO> _uploadedfiles = null;
List <Registration> _allusers = CustomerHandler.GetUsers();
Registration _userdetails = _allusers.Find(c => c.Iqama_NationalID == addClaimViewModel.ClientDTO.IDNumber);
if (addClaimViewModel != null)
{
_clmdet = new RequestCreateDTO();
_clmdet.PolicyNumber = _userdetails.PolicyNo;
_clmdet.HolderName = _userdetails.MemberName;
_clmdet.MemberID = addClaimViewModel.ClientDTO.IDNumber;
_clmdet.MemberName = _userdetails.MemberName;
_clmdet.NationalId = addClaimViewModel.NationalId;
_clmdet.RelationName = "";
_clmdet.ClaimTypeName = addClaimViewModel.ClaimTypeName;
_clmdet.CardNumber = _userdetails.CardNo;
_clmdet.CardExpireDate = null;
_clmdet.RequestDate = DateTime.Now;
_clmdet.ExpectedAmount = addClaimViewModel.ExpectedAmount;
_clmdet.VATAmount = addClaimViewModel.VATAmount;
_clmdet.Comment = addClaimViewModel.Comment;
ClientDTO client = new ClientDTO();
client.ClientName = _userdetails.MemberName;
client.IDNumber = addClaimViewModel.ClientDTO.IDNumber;
client.MobileNumber = _userdetails.MemberMobileNumber;
client.Email = "";
client.IBANNumber = addClaimViewModel.ClientDTO.IB0 + addClaimViewModel.ClientDTO.IB1 + addClaimViewModel.ClientDTO.IB2 + addClaimViewModel.ClientDTO.IB3 + addClaimViewModel.ClientDTO.IB4 + addClaimViewModel.ClientDTO.IB5 + addClaimViewModel.ClientDTO.IB6;
client.BankName = addClaimViewModel.ClientDTO.BankName;
_clmdet.ClientDTO = client;
_uploadedfiles = new List <RequestFileDTO>();
foreach (var file in addClaimViewModel.FilesUploaded)
{
if (file.Length > 0)
{
using (var ms = new MemoryStream())
{
RequestFileDTO requestFile = new RequestFileDTO();
requestFile.FileDesc = file.FileName;
requestFile.FilePath = file.FileName;
file.CopyTo(ms);
var fileBytes = ms.ToArray();
string s = Convert.ToBase64String(fileBytes);
requestFile.MyFile = fileBytes;
// act on the Base64 data
_uploadedfiles.Add(requestFile);
}
}
}
_clmdet.RequestFileList = _uploadedfiles;
}
return(_clmdet);
}
public async Task <ActionResult> AddForCharacter(int projectid, int characterid)
{
var field = await CharacterRepository.GetCharacterAsync(projectid, characterid);
if (field == null)
{
return(HttpNotFound());
}
return(View("Add", AddClaimViewModel.Create(field, CurrentUserId)));
}
public void CantSendClaimIfNoSlots()
{
Mock.Group.HaveDirectSlots = true;
Mock.Group.AvaiableDirectSlots = 0;
var vm = AddClaimViewModel.Create(Mock.Group, Mock.Player.UserId);
vm.IsAvailable.ShouldBeFalse();
vm.CanSendClaim.ShouldBeFalse();
vm.IsProjectRelatedReason.ShouldBeFalse();
}
public IActionResult AddClaim()
{
var model = new AddClaimViewModel
{
UserList = _userManager.Users.ToList(),
RoleList = _roleManager.Roles.ToList()
};
return(View(model));
}
public IActionResult AddClaim()
{
string Nid = TempData["NationalId"].ToString();
TempData.Keep("NationalId");
ViewBag.lang = langcode;
var userdetails = CustomerHandler.GetCustomerById(Nid);
ViewBag.MemberName = userdetails.MemberName;
var _viewm = new AddClaimViewModel();
_viewm._claimstypes = GetClaimTypesViewModel();
_viewm._bankNames = GetBankViewModel();
return(View(_viewm));
}
public async Task <IActionResult> AddClaimToUser(AddClaimViewModel addClaimViewModel)
{
var configBlob = AzureService.GetBlob("cdn", "private", null, null, $"user/{addClaimViewModel.user_id}", WebUIConfig.membershipFile);
var json = await configBlob.DownloadGenericObjectAsync();
var accounts = JsonUtils.GetJToken(Constants.JsontagAccount, json);
if (accounts == null)
{
var obj = new JObject();
var accountArray = new JArray();
accountArray.Add(addClaimViewModel.accountId);
obj.Add(Constants.JsontagAccount, accountArray);
await configBlob.UploadGenericObjectAsync(obj);
}
else
{
var accountArray = accounts as JArray;
accountArray.Add(addClaimViewModel.accountId);
await configBlob.UploadGenericObjectAsync(json);
}
var blob = AzureService.GetBlob("cdn", "private", null, null, $"account", "index.json");
var accJson = await blob.DownloadGenericObjectAsync();
if (!Object.ReferenceEquals(accJson, null))
{
foreach (var pair in accJson)
{
if (pair.Key == addClaimViewModel.accountId)
{
var obj = pair.Value as JObject;
var users = JsonUtils.GetJToken("users", obj) as JArray;
if (Object.ReferenceEquals(users, null))
{
obj.Add("users", new JArray {
addClaimViewModel.user_id
});
}
else
{
users.Add(addClaimViewModel.user_id);
}
await blob.UploadGenericObjectAsync(accJson);
}
}
}
return(RedirectToAction("ManageClaims", new { id = addClaimViewModel.user_id }));
}
public async Task <string> AddClaimReq(AddClaimViewModel _clm)
{
try
{
var loggedInUser = _authenticationService.GetAuthenticatedUser();
//string nationalId = TempData["NationalId"].ToString();
_clm.ClientDTO.IDNumber = loggedInUser.Iqama_NationalID;
_clm.NationalId = loggedInUser.Iqama_NationalID;
return(await _claimsHandler.AddClaimRequest(_clm));
}
catch (Exception ex)
{
_logger.LogInformation(_className + "::AddClaimReq::Exception::" + ex.Message);
}
return("false");
}
public async Task <ActionResult> AddForGroup(int projectid, int?characterGroupId)
{
if (characterGroupId == null)
{
var project = await ProjectRepository.GetProjectAsync(projectid);
return(RedirectToAction("AddForGroup",
new { project.ProjectId, project.RootGroup.CharacterGroupId }));
}
var field = await ProjectRepository.GetGroupAsync(projectid, characterGroupId.Value);
if (field == null)
{
return(HttpNotFound());
}
return(View("Add", AddClaimViewModel.Create(field, CurrentUserId)));
}
public async Task <IActionResult> AddClaimToUser(string id)
{
List <UserClaimViewModel> claims = new List <UserClaimViewModel>();
var configBlob = AzureService.GetBlob("cdn", "private", null, null, $"user/{id}", WebUIConfig.membershipFile);
var json = await configBlob.DownloadGenericObjectAsync();
var accounts = JsonUtils.GetJToken(Constants.JsontagAccount, json);
var accountBlob = AzureService.GetBlob("cdn", "private", null, null, "account", "index.json");
var accountJson = await accountBlob.DownloadGenericObjectAsync();
if (!Object.ReferenceEquals(accountJson, null))
{
foreach (var one in accountJson)
{
claims.Add(new UserClaimViewModel()
{
GUid = one.Key, Name = one.Value["name"].ToString()
});
}
}
var AccountArray = accounts == null ? null : accounts as JArray;
if (!Object.ReferenceEquals(AccountArray, null))
{
foreach (var account in AccountArray)
{
foreach (UserClaimViewModel o in claims)
{
if (o.GUid == account.ToString())
{
claims.Remove(o);
break;
}
}
}
}
var vm = new AddClaimViewModel
{
user_id = id,
claims = claims
};
return(View(vm));
}
public void NonPublicFieldsShouldNotBeShownOnCharacters()
{
var field = Mock.CreateField(new ProjectField()
{
IsPublic = false, CanPlayerEdit = false
});
var value = new FieldWithValue(field, "xxx");
Mock.Character.JsonData = new[] { value }.SerializeFields();
var vm = AddClaimViewModel.Create(Mock.Character, Mock.Player.UserId);
var fieldView = vm.Fields.Field(field);
_ = fieldView.ShouldNotBeNull();
fieldView.ShouldBeHidden();
fieldView.ShouldBeReadonly();
}
public async Task <IActionResult> AddClaim(AddClaimViewModel addClaimViewModel)
{
if (!ModelState.IsValid)
{
return(View(addClaimViewModel));
}
var claim = new Claim(addClaimViewModel.ClaimName, addClaimViewModel.ClaimValue);
if (!string.IsNullOrEmpty(addClaimViewModel.UserName))
{
var user = await _userManager.FindByNameAsync(addClaimViewModel.UserName);
if (user == null)
{
ModelState.AddModelError(string.Empty, "User not found!");
return(View(addClaimViewModel));
}
var result = await _userManager.AddClaimAsync(user, claim);
}
else if (!string.IsNullOrEmpty(addClaimViewModel.RoleName))
{
var role = await _roleManager.FindByNameAsync(addClaimViewModel.RoleName);
if (role == null)
{
ModelState.AddModelError(string.Empty, "Role not found!");
return(View(addClaimViewModel));
}
var result = await _roleManager.AddClaimAsync(role, claim);
}
return(RedirectToAction("Index", "Home"));
}
public async Task <ActionResult> AddForGroup(int projectid, int characterGroupId)
{
var field = await ProjectRepository.GetGroupAsync(projectid, characterGroupId);
return(WithEntity(field.Project) ?? View("Add", AddClaimViewModel.Create(field, GetCurrentUser())));
}
public string AddClaimRequest(AddClaimViewModel _clm)
{
return(AddClaimReq(_clm).Result);
}
