public async Task UpdateVoterAsync(VoterModel model)
{
using (var context = new StudentElectionContext())
{
var voter = await context.Voters.SingleOrDefaultAsync(v => v.Id == model.Id);
_mapper.Map(model, voter);
await context.SaveChangesAsync();
}
}
public ActionResult CreateVoter(VoterModel model)
{
model.CreatedBy = User.Identity.GetUserName();
var result = _votMgr.CreateVoter(model);
if (result.Succeeded == true)
{
TempData["message"] = $"Voter{model.VotName} was successfully added!";
return(RedirectToAction("Index"));
}
return(View(model));
}
public IActionResult Login(CredentialsModel credentials)
{
VoterModel voter = Logic.GetVoterByCredentials(credentials);
if (voter == null)
{
return(Unauthorized("Incorrect ID or ID production date"));
}
voter.JwtToken = JwtHelper.GetWjtToken(voter.VoterId, voter.IdProdDate.ToString());
return(Ok(voter));
}
public async Task <bool> IsVoterAlreadyVotedAsync(VoterModel voter)
{
var castedAt = DateTime.Now;
var count = await _ballotRepository.CountCastedBallotsAsync(voter.Id);
if (count > 1)
{
throw new ConstraintException($"Voter { voter.FullName } with VIN# { voter.Vin } has voted twice");
}
return(count > 0);
}
public async Task SaveVoterAsync(VoterModel voter)
{
voter.Vin = voter.Vin?.ToUpper();
if (voter.Id == 0)
{
await _voterRepository.InsertVoterAsync(voter);
}
else
{
await _voterRepository.UpdateVoterAsync(voter);
}
}
public async Task <bool> IsVinExistingAsync(int electionId, string vin, VoterModel model)
{
var voter = await GetVoterByVinAsync(electionId, vin);
if (model == null)
{
return(voter != null);
}
else
{
return(voter != null && voter.Id != model.Id);
}
}
public async Task InsertVoterAsync(VoterModel model)
{
var voter = new Voter();
_mapper.Map(model, voter);
using (var context = new StudentElectionContext())
{
context.Voters.Add(voter);
await context.SaveChangesAsync();
}
}
public async Task <bool> IsVinExistingAsync(int electionId, string vin, VoterModel voter)
{
var row = await GetVoterByVinAsync(electionId, vin);
if (voter == null)
{
return(row != null);
}
else
{
return(row != null && row.Id != voter.Id);
}
}
public Operation <List <VoterModel> > UploadStaffNames(Stream stream, VoterModel model)
{
return(Operation.Create((Func <List <VoterModel> >)(() =>
{
var sheet = _excel.Load <VoterModel>(stream);
var errors = new List <VoterModel>();
foreach (var row in sheet)
{
var staffNm = _db.Query <Voter>().Where(v => v.VoterId == row.VoterId).FirstOrDefault();
// var votername = _votgr.GetVoters().Result.Where(v => v.StaffName == model.StaffName).FirstOrDefault();
if (staffNm == null)
{
row.Message = "Voter does not exist";
errors.Add(row);
continue;
}
else
{
row.Message = "Voter does not exist";
}
row.CreatedBy = model.CreatedBy;
row.ModifiedBy = model.ModifiedBy;
row.StaffName = model.StaffName;
row.Department = row.Department;
row.StaffNo = model.StaffNo;
row.Email = model.Email;
row.StaffName = row.StaffName /*== staffNm.StaffName ? row.StaffName : staffNm.StaffName*/;
row.Department = row.Department;
row.StaffNo = row.StaffNo;
row.Email = row.Email /*== staffNm.StaffNo ? row.StaffNo : staffNm.StaffNo*/;
if (staffNm == null)
{
var entity = row.Create(row);
_db.Add(entity);
}
else
{
var entity = row.Edit(staffNm, row);
_db.Update(entity);
}
var result = _db.SaveChanges();
if (result.Succeeded == false)
{
row.Message = result.Message;
errors.Add(row);
}
}
return errors;
})));
}
public async Task <BallotModel> GetBallotAsync(ElectionModel election, VoterModel voter)
{
var existingBallot = await _ballotRepository.GetBallotByVinAsync(election.Id, voter.Vin);
if (existingBallot == null)
{
var enteredAt = DateTime.Now;
existingBallot = await _ballotRepository.InsertBallotAsync(voter, enteredAt);
existingBallot.Code = GetBallotCode(election.ServerTag, existingBallot);
await _ballotRepository.SetBallotCodeAsync(existingBallot);
}
return(existingBallot);
}
public async Task <BallotModel> InsertBallotAsync(VoterModel voter, DateTime enteredAt)
{
await Task.CompletedTask;
using (var tableAdapter = new BallotTableAdapter())
{
tableAdapter.Insert(
string.Empty,
enteredAt,
null,
voter.Id
);
}
return(await GetBallotByVinAsync(voter.ElectionId, voter.Vin));
}
public Operation <VoterModel> UpdateVoter(VoterModel model)
{
return(Operation.Create(() =>
{
//model.Validate();
var isExist = _context.Voters.Find(model.VoterId);
if (isExist == null)
{
throw new Exception("Voter does not exist");
}
var entity = model.Edit(isExist, model);
_context.Entry(entity);
_context.SaveChanges();
return model;
}));
}
public async Task <VoterModel> GetVoterByVinAsync(int electionId, string vin)
{
using (var context = new StudentElectionContext())
{
var voter = await context.Voters.SingleOrDefaultAsync(v => v.ElectionId == electionId && v.Vin == vin);
if (voter == null)
{
return(null);
}
var model = new VoterModel();
_mapper.Map(voter, model);
return(model);
}
}
public async Task <VoterModel> GetVoterAsync(int voterId)
{
using (var context = new StudentElectionContext())
{
var voter = await context.Voters.SingleOrDefaultAsync(v => v.Id == voterId);
if (voter == null)
{
return(null);
}
var model = new VoterModel();
_mapper.Map(voter, model);
return(model);
}
}
public async Task <BallotModel> InsertBallotAsync(VoterModel voter, DateTime enteredAt)
{
using (var context = new StudentElectionContext())
{
var ballot = new Ballot
{
Code = string.Empty,
EnteredAt = enteredAt,
VoterId = voter.Id
};
context.Ballots.Add(ballot);
await context.SaveChangesAsync();
}
return(await GetBallotByVinAsync(voter.ElectionId, voter.Vin));
}
public Operation <VoterModel> CreateVoter(VoterModel model)
{
return(Operation.Create(() =>
{
//model.Validate();
var isExists = _context.Voters.Where(c => c.VotName == model.VotName).FirstOrDefault();
if (isExists != null)
{
throw new Exception("restaurant already exist");
}
var entity = model.Create(model);
_context.Voters.Add(entity);
_context.SaveChanges();
return model;
}));
}
public async Task <VoterModel> GetVoterAsync(int voterId)
{
await Task.CompletedTask;
using (var tableAdapter = new VoterTableAdapter())
{
var row = tableAdapter.GetVotersById(voterId).SingleOrDefault();
if (row == null)
{
return(null);
}
var model = new VoterModel();
_mapper.Map(row, model);
return(model);
}
}
public async Task <VoterModel> GetVoterByVinAsync(int electionId, string vin)
{
await Task.CompletedTask;
using (var tableAdapter = new VoterTableAdapter())
{
var row = tableAdapter.GetVotersByVin(vin, electionId).SingleOrDefault();
if (row == null)
{
return(null);
}
var model = new VoterModel();
_mapper.Map(row, model);
return(model);
}
}
protected void showDetailsButton_Click(object sender, EventArgs e)
{
string voterId = voterIdTextBox.Text;
WebClient webClient = new WebClient();
var data = webClient.DownloadString("http://nerdcastlebd.com/web_service/voterdb/index.php/voters/all/format/json");
JObject jObject = JObject.Parse(data);
foreach (var person in jObject["voters"])
{
VoterModel voterModel = new VoterModel();
voterModel.ID = person["id"].ToString();
voterModel.Name = person["name"].ToString();
voterModel.Address = person["address"].ToString();
voterModel.DateOfBirth = person["date_of_birth"].ToString();
int currentyear = DateTime.Now.Year;
if (voterId == voterModel.ID)
{
voterIdTextBox.Text = voterModel.ID;
nameTextBox.Text = voterModel.Name;
addressTextBox.Text = voterModel.Address;
string[] birthyear = voterModel.DateOfBirth.Split('-');
int birthyear1 = int.Parse(birthyear[0]);
ageTextBox.Text = (currentyear - birthyear1).ToString();
}
}
string voter = voterIdTextBox.Text;
if (manager.IsPatientAlreadyExists(voter))
{
int serviceGiven = manager.GetServiceGivenByVoterId(voter);
serviceGivenTextBox.Text = Convert.ToString(serviceGiven);
}
else
{
serviceGivenTextBox.Text = "0";
}
}
public ActionResult EditVoter(VoterModel model)
{
if (ModelState.IsValid)
{
model.ModifiedBy = User.Identity.GetUserName();
var result = _votMgr.UpdateVoter(model);
if (result.Succeeded)
{
TempData["message"] = $"Voter{model.StaffName} was successfully added!";
ModelState.AddModelError(string.Empty, "Update was successfully ");
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, result.Message);
return(View(model));
}
}
return(View(model));
}
public async Task InsertVoterAsync(VoterModel voter)
{
await Task.CompletedTask;
using (var tableAdapter = new VoterTableAdapter())
{
tableAdapter.Insert(
voter.FirstName,
voter.MiddleName,
voter.LastName,
voter.Suffix,
(int)voter.Sex,
voter.Birthdate,
voter.Vin,
voter.YearLevel,
voter.Section,
voter.ElectionId
);
}
}
public ActionResult VoterNames(HttpPostedFileBase file, VoterModel model)
{
DropDown();
if (file != null && file.ContentLength != 0 && (System.IO.Path.GetExtension(file.FileName).ToLower() == ".xlsx" || System.IO.Path.GetExtension(file.FileName).ToLower() == ".xls"))
{
model.CreatedBy = User.Identity.GetUserName();
model.ModifiedBy = User.Identity.GetUserName();
var uploadedResult = _uploadMgr.UploadStaffNames(file.InputStream, model);
if (uploadedResult.Succeeded == false)
{
ViewBag.Error = $"{uploadedResult.Message}";
ModelState.AddModelError(string.Empty, uploadedResult.Message);
return(View(model));
}
//TempData["message"] = new ResponseModel { Success = $"Voter Names was successfully Uploaded!", Error = "" };
//return RedirectToAction("AdmittedStudents");
}
ModelState.AddModelError(string.Empty, "Only Excel Sheets are allowed");
return(View(model));
}
public ActionResult Login(VoterModel voter)
{
if (ModelState.IsValid)
{
voter.StudentNumber = dao.VoterLogin(voter);
if (voter.StudentNumber != null)
{
Session["studentNumber"] = voter.StudentNumber;
ViewBag.Session = Session["studentNumber"];
return(RedirectToAction("Index"));
}
else
{
ViewBag.Message = $"Error {dao.message}!";
return(View("Error"));
}
}
else
{
return(View(voter));
}
}
public ActionResult CreateVoter(VoterModel model)
{
if (ModelState.IsValid)
{
try
{
model.CreatedBy = User.Identity.GetUserName();
//model.Email = User.Identity.GetUserName();
//model.StaffNo = User.Identity.GetUserId();
var result = _votMgr.CreateVoter(model);
if (result.Succeeded == true)
{
TempData["message"] = $"Voter{model.StaffName} was successfully added!";
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
throw ex;
}
}
return(View(model));
}
//[ValidateAntiForgeryToken]
public ActionResult UploadVoters(HttpPostedFileBase file, VoterModel model)
{
DropDown();
try
{
if (file != null && file.ContentLength != 0 && (System.IO.Path.GetExtension(file.FileName).ToLower() == ".xlsx" || System.IO.Path.GetExtension(file.FileName).ToLower() == ".xls"))
{
model.CreatedBy = User.Identity.GetUserName();
model.ModifiedBy = User.Identity.GetUserName();
var uploadedResult = _votMgr.UploadVoterNames(file.InputStream, model);
if (uploadedResult.Succeeded == true)
{
TempData["message"] = $" Voter was successfully Uploaded!";
return(RedirectToAction("Index"));
}
//else
//{
// ModelState.AddModelError(string.Empty, uploadedResult.Message);
// ViewBag.Error = $"Error occured : {uploadedResult.Message}";
// return View(model);
//}
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
}
//else
//{
// ViewBag.Error = "Only Excel Sheets are allowed";
//}
//}
return(View());
}
public async Task <bool> IsVinExistingAsync(int electionId, string vin, VoterModel voter)
{
return(await _voterRepository.IsVinExistingAsync(electionId, vin, voter));
}
public async Task DeleteVoterAsync(VoterModel voter)
{
await _voterRepository.DeleteVoterAsync(voter);
}
public async Task <BallotModel> GetBallotByVinAsync(ElectionModel election, VoterModel voter)
{
return(await _ballotRepository.GetBallotByVinAsync(election.Id, voter.Vin));
}
private async void btnAdd_Click(object sender, RoutedEventArgs e)
{
IsCanceled = false;
try
{
int.TryParse(cmbGradeLevel.Text, out int yearLevel);
var voter = new VoterModel
{
LastName = txtLastName.Text.Trim(),
FirstName = txtFirstName.Text.Trim(),
MiddleName = txtMiddleName.Text.Trim(),
Suffix = txtSuffix.Text.Trim(),
YearLevel = yearLevel,
Section = txtStrandSection.Text.Trim(),
Sex = (Sex)(cmbSex.SelectedIndex + 1),
Birthdate = dpBirthdate.SelectedDate.HasValue ? dpBirthdate.SelectedDate.Value.Date : default(DateTime?),
Vin = txtVoterID.Text.Trim(),
ElectionId = _currentElection.Id
};
G.WaitLang(this);
if (string.IsNullOrWhiteSpace(voter.Vin))
{
G.EndWait(this);
MessageBox.Show("Enter voter ID", "Voter", MessageBoxButton.OK, MessageBoxImage.Error);
txtVoterID.Focus();
return;
}
if (await _voterService.IsVinExistingAsync(_currentElection.Id, voter.Vin, Voter))
{
G.EndWait(this);
MessageBox.Show("Voter ID is already in use", "Voter", MessageBoxButton.OK, MessageBoxImage.Error);
txtVoterID.Focus();
return;
}
if (string.IsNullOrWhiteSpace(voter.FirstName))
{
G.EndWait(this);
MessageBox.Show("Enter voter's first name", "Voter", MessageBoxButton.OK, MessageBoxImage.Error);
txtFirstName.Focus();
return;
}
if (string.IsNullOrWhiteSpace(voter.LastName))
{
G.EndWait(this);
MessageBox.Show("Enter voter's last name", "Voter", MessageBoxButton.OK, MessageBoxImage.Error);
txtLastName.Focus();
return;
}
if (voter.Sex == Sex.Unknown)
{
G.EndWait(this);
MessageBox.Show("Select voter's sex", "Voter", MessageBoxButton.OK, MessageBoxImage.Error);
cmbSex.Focus();
return;
}
if (voter.YearLevel == 0)
{
G.EndWait(this);
MessageBox.Show("Enter voter's year level", "Voter", MessageBoxButton.OK, MessageBoxImage.Error);
cmbGradeLevel.Focus();
return;
}
if (string.IsNullOrWhiteSpace(voter.Section))
{
G.EndWait(this);
MessageBox.Show("Enter voter's class section", "Voter", MessageBoxButton.OK, MessageBoxImage.Error);
txtStrandSection.Focus();
return;
}
G.EndWait(this);
if (Voter == null)
{
await _voterService.SaveVoterAsync(voter);
G.EndWait(this);
MessageBox.Show("New voter added!", "Voter", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
voter.Id = Voter.Id;
await _voterService.SaveVoterAsync(voter);
G.EndWait(this);
MessageBox.Show("Successfully updated!", "Voter", MessageBoxButton.OK, MessageBoxImage.Information);
}
await(Owner as MaintenanceWindow).LoadVotersAsync();
Close();
}
catch (Exception ex)
{
Logger.LogError(ex);
G.EndWait(this);
MessageBox.Show(ex.GetBaseException().Message, "PROGRAM ERROR: " + ex.Source, MessageBoxButton.OK, MessageBoxImage.Stop);
}
}
