public async Task <IActionResult> Create([Bind("Id,FirstName,LastName,PhoneNumber,Email,VeteranStreet,VeteranCity,VeteranState,VeteranZipCode")] Veteran veteran)
{
string url = $"https://maps.googleapis.com/maps/api/geocode/json?address={veteran.VeteranStreet},+{veteran.VeteranCity},+{veteran.VeteranState}&key={APIKeys.GeocodeKey}";
HttpClient client = new HttpClient();
HttpResponseMessage response = await client.GetAsync(url);
string jsonResult = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
JObject geoCode = JObject.Parse(jsonResult);
veteran.Lat = (double)geoCode["results"][0]["geometry"]["location"]["lat"];
veteran.Long = (double)geoCode["results"][0]["geometry"]["location"]["lng"];
}
if (ModelState.IsValid)
{
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
veteran.IdentityUserId = userId;
veteran.ImageLocation = null;
_context.Add(veteran);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(veteran));
}
public ActionResult EditProfilePicture(Veteran veteran)
{
Veteran veteranToUpdate = db.Veterans.Single(v => v.Id == veteran.Id);
veteranToUpdate.ProfilePicture = veteran.ProfilePicture;
try
{
db.SaveChanges();
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
raise = new InvalidOperationException(message, raise);
}
}
throw raise;
}
return(RedirectToAction("PortfolioCreation", viewModel));
}
public IHttpActionResult Post(VeteranBindingModel veteranBindingModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Veteran veteran = Mapper.Map <VeteranBindingModel, Veteran>(veteranBindingModel);
var userId = User.Identity.GetUserId();
if (userId == null)
{
return(BadRequest());
}
var user = _userService.GetById(userId);
veteran.User = user;
_veteranService.Add(veteran);
var veteranViewModel = Mapper.Map <Veteran, VeteranViewModel>(veteran);
return(Ok(veteranViewModel));
}
private Property Insertable(Veteran veteran, VeteranRepository veterans)
{
var inserted = veterans.Create(veteran);
var equal = inserted.Equals(veteran);
return(equal.ToProperty());
}
private Property Lifecycle(Veteran veteran, VeteranRepository repository)
{
return(Insertable(veteran, repository)
.And(Updateable(veteran, repository))
.And(Gettable(veteran, repository))
.And(Deleteable(veteran, repository)));
}
private Property Deleteable(Veteran veteran, VeteranRepository veterans)
{
veterans.Delete(veteran);
var equal = veterans.Get(veteran.Id) == null;
return(equal.ToProperty());
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
model.Email = model.UserName + "@msr.com";
Veteran ExisitingVeteran = db.Veterans.Find(Int32.Parse(model.UserName));
var ExistingUser = UserManager.FindByName(model.UserName);
if (ExisitingVeteran != null && ExistingUser == null)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
Email = model.Email, UserName = model.UserName
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
private void Btn_SaveRecord_Click(object sender, RoutedEventArgs e)
{
Veteran.WriteDataToDatabase();
// Setup a new record for editing
LoadNew();
}
public async Task <IActionResult> Edit(int id, [Bind("Id,FirstName,LastName,PhoneNumber,Email,ImageLocation,VeteranStreet,VeteranCity,VeteranState,VeteranZipCode,IdentityUserId")] Veteran veteran)
{
if (id != veteran.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(veteran);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VeteranExists(veteran.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdentityUserId"] = new SelectList(_context.Users, "Id", "Id", veteran.IdentityUserId);
return(View(veteran));
}
public override void EquipUnit(Equipment input)
{
if (input is Veteran)
{
veteranRule = input as Veteran;
}
else if (input is FieldFortification)
{
fieldFortification = input as FieldFortification;
}
else if (input is UnitLeader)
{
champion = input as UnitLeader;
}
else if (input is BannerBearer)
{
bannerBearer = input as BannerBearer;
}
else if (input is Muscicians)
{
muscician = input as Muscicians;
}
else
{
base.EquipUnit(input);
}
}
/// <summary>
/// Displays the veteran's profile with options to select libraries or start their intake form
/// </summary>
public async Task OnGetAsync()
{
Veteran veteran = await _veteranService.GetVeteranByPrincipalAsync(User);
Libraries = await _libraryService.GetAllLibrariesForVeteranAsync(veteran.ApplicationUserId);
Match = await _matchService.GetMatchAsync();
}
public async Task <IActionResult> OnGet(string id, string code, string SelectedUserType)
{
ApplicationUser user = await _userManager.FindByIdAsync(id);
if (!string.IsNullOrWhiteSpace(code) &&
(await _userManager.ConfirmEmailAsync(user, code)).Succeeded)
{
//If link is valid, set email confirmed to true for the account.
user.EmailConfirmed = true;
await _userManager.UpdateAsync(user);
if (ModelState.IsValid)
{
string fullname = $"{user.FirstName} {user.MiddleInitial} {user.LastName}";
Claim name = new Claim(ClaimTypes.Name, fullname, ClaimValueTypes.String);
Claim userEmail = new Claim(ClaimTypes.Email, user.Email, ClaimValueTypes.String);
List <Claim> claims = new List <Claim> {
name, userEmail
};
await _userManager.AddClaimsAsync(user, claims);
//If the link is for a lawyer account, redirect to lawyer confirmation page
if (SelectedUserType == ApplicationRoles.Lawyer)
{
Email = user.Email;
return(RedirectToPage("/Accounts/LawyerVerification"));
}
else if (SelectedUserType == ApplicationRoles.Veteran)
{
//Create veteran role if it does not exist
if (!await _roleManager.RoleExistsAsync(ApplicationRoles.Veteran))
{
await _roleManager.CreateAsync(new IdentityRole(ApplicationRoles.Veteran));
}
if (ModelState.IsValid)
{
// Adding Role to Veteran account
await _userManager.AddToRoleAsync(user, ApplicationRoles.Veteran);
// Populate Veteran Table with new account
Veteran newVet = new Veteran {
ApplicationUserId = user.Id
};
await _context.Veterans.AddAsync(newVet);
await _context.SaveChangesAsync();
}
return(RedirectToPage("/Accounts/EmailConfirmed"));
}
}
}
//Catch all default for when the link is invalid
ViewData["error"] = "Something went wrong with your confirmation, your link may have been damaged.";
return(RedirectToPage(nameof(RegisterModel)));
//TODO create page that will resend confirmation email with valid link
}
/// <summary>
/// Initializes a new instance of the <see cref="ScanError"/> class with the specified <paramref name="scan"/>, <paramref name="veteran"/>, and <paramref name="message"/>.
/// </summary>
/// <param name="scan">The Scan to include in the response.</param>
/// <param name="veteran">The Veteran associated with the scan, if applicable.</param>
/// <param name="message">The error message associated with the scan.</param>
public ScanError(Scan scan, Veteran veteran, string message)
{
EventId = scan.EventId;
VeteranId = scan.VeteranId;
Veteran = veteran;
ServiceId = scan.ServiceId;
PlusOne = scan.PlusOne;
Message = message;
}
public ActionResult CreateVeteran([Bind(Include = "Id,FirstName,MiddleName,Surname,DOB,BirthPlace,Death,MaritalStatus,EnlistedDate,EmbarkmentAge,RegimentNumber,Battalion,Religion,Address,State,Country,ShortBio,Fate,Status,ProfilePicture,Fk_User_Id,Fk_Veteran_Queue_Id,PreWarOccupation,NextOfKin")] Veteran veteran)
{
if (ModelState.IsValid)
{
db.Veterans.Add(veteran);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(veteran));
}
public void SetGetID()
{
Veteran veteran = new Veteran()
{
ApplicationUserId = _user.Id,
ApplicationUser = _user
};
Assert.Equal("00000000-0000-0000-0000-000000000000", veteran.ApplicationUserId);
}
/// <summary>
/// Initializes a new instance of the <see cref="ScanResponse"/> class with the specified <paramref name="scan"/> and <paramref name="veteran"/>.
/// </summary>
/// <param name="scan">The Scan to include in the response.</param>
/// <param name="veteran">The Veteran associated with the scan, if applicable.</param>
public ScanResponse(Scan scan, Veteran veteran)
{
EventId = scan.EventId;
VeteranId = scan.VeteranId;
Veteran = veteran;
ServiceId = scan.ServiceId;
PlusOne = scan.PlusOne;
ScanBy = scan.ScanBy;
ScanById = scan.ScanById;
ScanDate = scan.ScanDate;
}
public void SetGetVetId()
{
Veteran veteran = new Veteran()
{
ApplicationUserId = _match.VeteranApplicationUserId,
VetLawMatch = _match
};
Assert.Equal("1", veteran.VetLawMatch.VeteranApplicationUserId);
}
public void Coordinates_TestingGetter_ReturnString()
{
// Arrange
Veteran n = new Veteran();
// Act
n.Coordinates = "Veteran";
// Assert
Assert.Equal("Veteran", n.Coordinates);
}
public void SetGetMatchID()
{
Veteran veteran = new Veteran()
{
ApplicationUserId = _match.ID.ToString(),
VetLawMatch = _match,
};
Assert.Equal("1", veteran.VetLawMatch.ID.ToString());
}
public Veteran GetById(int id)
{
Veteran veteran = _veteranRepository.GetById(id);
if (veteran == null)
{
return(null);
}
return(!veteran.IsDeleted ? veteran : null);
}
private IActionResult UpdateScan(Scan scan, Veteran veteran)
{
try
{
var updatedScan = ScanRepository.Update(scan);
return(StatusCode(201, new ScanResponse(updatedScan, veteran)));
}
catch (Exception ex)
{
throw new Exception($"Error processing Scan: {ex.Message}. See inner Exception for details.", ex);
}
}
public void GetSetCity()
{
Veteran veteran = new Veteran()
{
City = "Seattle"
};
Assert.Matches("Seattle", veteran.City);
veteran.City = "Redmond";
Assert.Matches("Redmond", veteran.City);
}
public void GetSetState()
{
Veteran veteran = new Veteran()
{
State = "Washington"
};
Assert.Matches("Washington", veteran.State);
veteran.State = "California";
Assert.Matches("California", veteran.State);
}
public void GetSetZIP()
{
Veteran veteran = new Veteran()
{
ZipCode = 98122
};
Assert.Equal(98122, veteran.ZipCode);
veteran.ZipCode = 98121;
Assert.Equal(98121, veteran.ZipCode);
}
private Property Updateable(Veteran veteran, VeteranRepository veterans)
{
veteran.FirstName = "TestFirstName";
veteran.LastName = "TestLastName";
veteran.CardNumber = 1234567;
veteran.Address = "1111 1st street";
veteran.PrimaryPhone = "(123) 123-1234";
veteran.Email = "*****@*****.**";
veteran.EnrollmentDate = DateTime.Now;
var updated = veterans.Update(veteran);
var equal = updated.Equals(veteran);
return(equal.ToProperty());
}
/// <summary>
/// The veteran has chosen to save their library selection changes. Establish new relationships
/// based on the veteran's choices and deleted newly orphaned ones via the VeteranLibraryJunction table
/// </summary>
/// <returns></returns>
public async Task <IActionResult> OnPostAsync()
{
// Get the currently signed in veteran
Veteran veteran = await _veteranService.GetVeteranByPrincipalAsync(User);
// Attempt to update the state of the VeteranLibraryJunction table based on the veteran's POSTed choices
if (!ModelState.IsValid || !(await _veteranService.MergeLibraryListWithVeteranAsync(
veteran.ApplicationUserId, SelectedLibraries)))
{
// The changes could not be ma/de. Display the page to the user again with validation errors (if
// applicable) to give them another chance to commit their changes
return(Page());
}
// Success! Redirect to index
return(RedirectToPage("Index"));
}
private void Btn_DeleteRecord_Click(object sender, RoutedEventArgs e)
{
MessageBoxResult result;
result = MessageBox.Show(Tools.deleteMessage, Tools.deleteTitle, MessageBoxButton.YesNo);
if (result == MessageBoxResult.Yes)
{
Veteran.DeleteFromDatabase();
mainWin.DataContext = null;
mainWin.MainWindowContent = new Veterans(mainWin);
mainWin.DataContext = mainWin;
// User has deleted the record, discarding the changed data
Tools.hasDataChanged = false;
}
}
public ActionResult AddOrEdit(PersonViewModel model)
{
var item = new Veteran();
if (model.PersonId > 0)
{
item = Db.Get <Veteran>(model.PersonId);
}
item = Mapper.Map(model, item);
var result = Db.SaveOrUpdate(item);
var path = Path.Combine(Server.MapPath($"~/{"Content/images/veteran"}/{result}"));
var directoryInfo = new DirectoryInfo(path);
directoryInfo.Create();
return(RedirectToAction("List"));
}
public Veteran MapperDataVeteran(Dictionary <string, string> dictionaryDataFromForm)
{
var veteran = new Veteran
{
FirstName = dictionaryDataFromForm["FirstName"],
LastName = dictionaryDataFromForm["LastName"],
MiddleName = dictionaryDataFromForm["MiddleName"],
Description = dictionaryDataFromForm["Description"],
DateBirth = Convert.ToDateTime(dictionaryDataFromForm["DateBirth"]),
BirthPlace = dictionaryDataFromForm["BirthPlace"],
DateDeath = Convert.ToDateTime(dictionaryDataFromForm["DateDeath"]),
Latitude = Convert.ToDouble(dictionaryDataFromForm["Latitude"]),
Longitude = Convert.ToDouble(dictionaryDataFromForm["Longitude"]),
Called = Convert.ToDateTime(dictionaryDataFromForm["Called"]),
Awards = dictionaryDataFromForm["Awards"],
Troops = dictionaryDataFromForm["Troops"]
};
return(veteran);
}
public override void RemoveEquipment(Equipment output)
{
if (output is UnitLeader)
{
champion = null;
}
else if (output is Muscicians)
{
muscician = null;
}
else if (output is BannerBearer)
{
bannerBearer = null;
}
else if (output is Veteran)
{
veteranRule = new GenericVeteran();
}
else
{
base.RemoveEquipment(output);
}
}
