private static AddressType MapAddresses(Nomination source)
{
var addresses = new AddressType();
var address = new Address
{
StreetName = source.AddressLine1,
SuburbName = source.City,
StateTerritory = source.State,
PostCode = source.Postcode,
Country = MappingConstants.Country
};
addresses.Add(address);
if (!string.IsNullOrWhiteSpace(source.PostalAddressLine1))
{
address = new Address
{
StreetName = source.PostalAddressLine1,
SuburbName = source.PostalCity,
StateTerritory = source.PostalState,
PostCode = source.PostalPostcode,
Country = MappingConstants.Country
};
addresses.Add(address);
}
return(addresses.Any() ? addresses : null);
}
public IActionResult comment(ViewNomVM model)
{
Nomination current = _db.Nomination.Where(a => a.NominationId == model.Nomination.NominationId).Include(a => a.University).FirstOrDefault();
if (model.NewComment != null)
{
Comment newComment = new Comment();
newComment.Message = model.NewComment;
newComment.ApplicantId = HttpContext.GetLoggedUser().Id;
newComment.IonId = current.NominationId;
newComment.CommentTime = DateTime.Now;
var admini = _db.Administrator.Include(a => a.ApplicationUser).ToList();
foreach (var x in admini)
{
_notificationService.sendToAdmin(x.AdministratorId, HttpContext.GetLoggedUser().Id, new IRO_UNMO.App.Subscription.NotificationVM()
{
Message = model.NewComment,
Url = "/admin/nomination/view/" + current.NominationId
});
}
_db.Comment.Add(newComment);
_db.SaveChanges();
}
else
{
return(RedirectToAction("view", "nomination", new { id = model.Nomination.NominationId }));
}
return(RedirectToAction("view", "nomination", new { id = model.Nomination.NominationId }));
}
public RepositoryResponse LoadEmpNominationDetails(long ID, string nominationID, string empNum)
{
baseModel = new RepositoryResponse();
try
{
using (objSOMEntities = new SOMEntities())
using (objIPEntities = new IntranetPortalEntities())
{
EmpMaster a = new EmpMaster();
Nomination c = new Nomination();
var _NomDetails = (from em in objIPEntities.EmpMasters.AsEnumerable()
join nom in objSOMEntities.Nominations.AsEnumerable() on em.EmployeeNumber equals nom.EmployeeNumber.ToString()
where nom.IsActive == true && nom.NominationId == nominationID && em.EmployeeNumber == empNum
select new { em, nom }).OrderByDescending(r => r.nom.ID).FirstOrDefault();
var _data = objSOMEntities.Evaluations.Where(r => r.ID == ID && r.IsActive == true).FirstOrDefault();
EvaluationModel model = ConvertEvaluation_DB2Model(_NomDetails.em, _data, _NomDetails.nom, 1);
baseModel = new RepositoryResponse {
success = true, message = "Get Evaluation details Successfully", Data = model
};
}
}
catch (Exception ex)
{
baseModel = new RepositoryResponse {
success = false, message = ex.ToString()
};
}
return(baseModel);
}
private static List <ContactTelephone> MapContactTelephone(Nomination source)
{
var contactTelephoneList = new List <ContactTelephone>();
if (!string.IsNullOrWhiteSpace(source.HomePhone))
{
contactTelephoneList.Add(new ContactTelephone
{
Usage = ContactTelephoneUsage._01,
TelephoneNumber = source.HomePhone
});
}
if (!string.IsNullOrWhiteSpace(source.BusinessPhone))
{
contactTelephoneList.Add(new ContactTelephone
{
Usage = ContactTelephoneUsage._02,
TelephoneNumber = source.BusinessPhone
});
}
if (!string.IsNullOrWhiteSpace(source.MobilePhone))
{
contactTelephoneList.Add(new ContactTelephone
{
Usage = ContactTelephoneUsage._03,
TelephoneNumber = source.MobilePhone
});
}
return(contactTelephoneList);
}
public async Task <IActionResult> Edit(int?contestId, int id, [Bind("Id,Name,Description,ContestId")] Nomination nomination)
{
if (id != nomination.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(nomination);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!NominationExists(nomination.Id))
{
return(NotFound());
}
else
{
throw;
}
}
ViewData["ContestName"] = _context.Contests.FirstOrDefault(x => x.Id == nomination.ContestId).Name;
ViewData["ContestId"] = contestId;
return(RedirectToAction("Nominations", "Contests", new { id = contestId }));
}
ViewData["ContestId"] = new SelectList(_context.Contests, "Id", "Name", nomination.ContestId);
return(View(nomination));
}
public async Task <IActionResult> UpdateNomination(
[FromBody] Nomination nominationToUpdate)
{
//find nomination to be updated by id
var nomination = await _individualNominationCatalogContext.Nominations
.Where(i => i.Id == nominationToUpdate.Id)
.SingleOrDefaultAsync();
//if it does not exist
if (nomination == null)
{
return(NotFound(new { Message = $"Nomination with id {nominationToUpdate.Id} not found." }));
}
//if found, add update to nomination in table
//save changes
nomination = nominationToUpdate;
//nomination.UpdatedDate.Add(DateTime);
_individualNominationCatalogContext.Nominations.Update(nomination);
await _individualNominationCatalogContext.SaveChangesAsync();
return(CreatedAtAction(nameof(GetNominationById), new { id = nominationToUpdate.Id }));
}
public static async void Delete(Nomination nomination)
{
using (HttpClient client = new HttpClient())
{
HttpResponseMessage response = await client.DeleteAsync("https://localhost:44366/api/Nominations/" + nomination.Id);
}
}
public void AddNomination(int categoryId, int movieId, List <string> creditIds)
{
using (var ctx = new MovieContext())
{
var selectedMovie = ctx.Movies
.SingleOrDefault(x => x.Id == movieId);
var selectedCredits = ctx.Credits
.Where(x => creditIds.Contains(x.Id))
.ToList();
var selectedCategory = ctx.Caterogries
.SingleOrDefault(cat => cat.Id == categoryId);
Nomination nomination = new Nomination
{
Category = selectedCategory,
Movie = selectedMovie,
Credits = selectedCredits,
};
ctx.Nominations.Add(nomination);
ctx.SaveChanges();
}
}
public ActionResult UpdateNominationForm(Nomination model)
{
model.Ward = null;
db.Entry(model).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", "Nominations"));
}
public ActionResult PostNominationForm(Nomination model)
{
var userId = System.Web.HttpContext.Current.User.Identity.GetUserId();
var user = User.IsInRole("Admin");
if (ModelState.IsValid)
{
var userDetails = db.UserDetails.Where(m => m.UserId == userId).FirstOrDefault();
model.UserDetailsId = userDetails.Id;
model.Status = NominationStatus.Pending;
db.Nominations.Add(model);
db.SaveChanges();
int nominationId = model.Id;
ApprovalStages approvalStage = db.ApprovalStages.OrderBy(o => o.Order).FirstOrDefault();
NominationApprovals nominationApproval = new NominationApprovals();
nominationApproval.ApprovalStagesId = approvalStage.Id;
nominationApproval.MedalId = model.MedalId;
nominationApproval.NominationId = nominationId;
nominationApproval.Status = false;
db.NominationApprovals.Add(nominationApproval);
db.SaveChanges();
return(RedirectToAction("Index", "Nominations"));
}
return(RedirectToAction("Create", "Nominations"));
}
public ActionResult PostNominationApprovals(List <ApprovalViewModel> model)
{
var userId = System.Web.HttpContext.Current.User.Identity.GetUserId();
foreach (var item in model)
{
var currNomStage = db.NominationApprovals.Find(item.Id);
currNomStage.ApproverId = userId;
currNomStage.MedalId = item.MedalId;
currNomStage.Status = item.Status;
currNomStage.ApprovalDate = DateTime.Now;
db.Entry(currNomStage).State = EntityState.Modified;
db.SaveChanges();
var nextApprovalLevel = GetNextApproval(currNomStage.ApprovalStagesId);
if (nextApprovalLevel != null)
{
NominationApprovals approval = new NominationApprovals();
approval.ApprovalStagesId = nextApprovalLevel.Id;
approval.MedalId = currNomStage.MedalId;
approval.NominationId = currNomStage.NominationId;
approval.Status = false;
db.NominationApprovals.Add(approval);
db.SaveChanges();
}
else
{
Nomination nomination = db.Nominations.Find(currNomStage.NominationId);
nomination.Status = NominationStatus.Awarded;
db.Entry(nomination).State = EntityState.Modified;
db.SaveChanges();
}
}
return(RedirectToAction("Approve", "Nominations"));
}
// GET: Nominations/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Nomination nomination = db.Nominations.Find(id);
if (nomination == null)
{
return(HttpNotFound());
}
ViewBag.NominationBodyId = new SelectList(db.NominatingBodies, "Id", "Name");
ViewBag.NominationPeriodId = new SelectList(db.NominationPeriods, "Id", "Name");
ViewBag.SalutationId = new SelectList(db.Salutations, "Id", "Name");
ViewBag.CountryId = new SelectList(db.Countries, "Id", "Name");
ViewBag.CountyId = new SelectList(db.Counties, "Id", "CountyName");
ViewBag.CountyOfBirthId = new SelectList(db.Counties, "CountyName", "CountyName");
ViewBag.SubCountyId = new SelectList(db.SubCounties, "Id", "SubCountyName");
ViewBag.WardId = new SelectList(db.Wards, "Id", "WardName");
ViewBag.MedalId = new SelectList(db.Medals.OrderBy(o => o.OrderBy), "Id", "Name");
ViewBag.AcademicQualificationId = new SelectList(db.AcademicQualifications, "Id", "Name");
ViewBag.OccupationId = new SelectList(db.Occupations, "Id", "Name");
return(View(nomination));
}
public async Task <ActionResult> VoteOnNomination(VoteViewModel voteViewModel)
{
if (voteViewModel.Vote.Id != 0)
{
VoteAPI.Update(voteViewModel.Vote);
}
else if (voteViewModel.Vote.Id == 0)
{
VoteAPI.Create(voteViewModel.Vote);
}
;
Nomination nomination = await NominationAPI.GetById(voteViewModel.Vote.NominationId);
YearCategoryModel returnParameters = new YearCategoryModel(nomination.Year, nomination.AwardCategory);
Nomination nominationVotedFor = await NominationAPI.GetById(voteViewModel.Vote.NominationId);
RecommendationViewModel recommendationViewModel = new RecommendationViewModel()
{
Year = nominationVotedFor.Year,
Category = nominationVotedFor.AwardCategory
};
recommendationViewModel.Movie = await MovieAPI.GetById(nominationVotedFor.MovieId);
recommendationViewModel.MovieId = recommendationViewModel.Movie.Id;
return(RedirectToAction(nameof(MovieRecommendation), recommendationViewModel));
}
public ActionResult Create(NominationViewModel ViewModel)
{
Nomination nomination = ViewModel.nomination;
if (ModelState.IsValid)
{
db.Nominations.Add(nomination);
foreach (Application application in ViewModel.applications)
{
var original = db.Applications.Find(application.id);
if (application.shortlisted != original.shortlisted)
{
original.modified = DateTime.Now;
original.modified_by = User.Identity.Name;
original.shortlisted = application.shortlisted;
db.Entry(original).State = EntityState.Modified;
}
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.status_id = new SelectList(db.NominationStatus, "id", "name", nomination.status_id);
ViewBag.program_id = new SelectList(db.Programs, "id", "name", nomination.program_id);
return(View(ViewModel));
}
private static Nomination LoadSuperStarAwardsNominationFromSurveyExport(Row row, int rowNumber)
{
var isAnonymousNominator = row[10] != @"Display My Name (Recommended)";
var nominatorName = PersonName.CreateForNominator(row[9], isAnonymousNominator);
var nomineeName = PersonName.Create(row[12]);
var awardType = AwardType.SuperStar;
var nomineeOfficeLocation = OfficeLocation.FindByName(row[14]);
var hasContinuouslyImproving = !string.IsNullOrWhiteSpace(row[15]);
var hasDrivingInnovation = !string.IsNullOrWhiteSpace(row[16]);
var hasDelightingCustomers = !string.IsNullOrWhiteSpace(row[17]);
var hasBehavingWithIntegrity = !string.IsNullOrWhiteSpace(row[18]);
var hasDeliveringMeaningfulOutcomes = !string.IsNullOrWhiteSpace(row[19]);
var hasStreamingGood = !string.IsNullOrWhiteSpace(row[20]);
var writeUp = NominationWriteUp.Create(nomineeName, row[21]);
var writeUpSummary = NominationWriteUpSummary.NotApplicable;
var companyValues = GetCompanyValues(hasContinuouslyImproving, hasDrivingInnovation, hasDelightingCustomers,
hasBehavingWithIntegrity, hasDeliveringMeaningfulOutcomes, hasStreamingGood);
var nominee = Person.Create(nomineeName, nomineeOfficeLocation, nomineeName.DerivedEmailAddress);
var nomination = new Nomination(rowNumber, NomineeVotingIdentifier.Unknown, nominee, awardType,
nominatorName, companyValues, writeUp, writeUpSummary);
return(nomination);
}
public void Delete(int id)
{
Nomination nomination = _repo.Nomination.GetNominationById(id);
_repo.Nomination.Delete(nomination);
_repo.Save();
}
public ResultNomination(Nomination nomination, IList <Vote> votes)
{
Nomination = nomination;
int max = votes.Where(v => v.Nomination == nomination).Max(v => v.Value);
Team = votes.Where(v => v.Nomination == nomination && v.Value == max).Select(v => v.Team).FirstOrDefault();
}
public async Task Default([Remainder] string mov)
{
Console.WriteLine("Got vote");
if (_votingService.VotingOpen())
{
var noms = _nominationsService.GetNominations();
Nomination nomination = null;
try
{
nomination = noms.Single(x => x.Name.ToLower().Equals(mov.ToLower()));
}
catch
{
await ReplyAsync($"Unexpected vote for {mov}, please try again!");
}
if (!noms.Any())
{
await ReplyAsync($"Unexpected vote for {mov}, please try again!");
}
else
{
_votingService.Vote(Context.User, nomination.VotingId);
await ReplyAsync($"{Context.User.Username}, your vote has been registered!");
}
}
else
{
await ReplyAsync($"There is no vote in progress");
}
}
private bool IsHistoricalNomination(Nomination nomination)
{
var customDate = _customDateService.GetCustomDate(nomination.AwardId);
var currentNomination = nomination;
var award = _encourageDatabaseContext.Query <Award>().FirstOrDefault(n => n.Id == currentNomination.AwardId);
var nominationDate = Convert.ToDateTime(currentNomination.NominationDate);
bool isHistoricalNomination = false;
if (award != null)
{
switch (award.Code)
{
default:
case "SOM":
var prevMonth = customDate;
if ((nominationDate.Year < prevMonth.Year) || (nominationDate.Year == prevMonth.Year && nominationDate.Month < prevMonth.Month))
{
isHistoricalNomination = true;
}
break;
case "PINNACLE":
if (nominationDate.Year < customDate.Year)
{
isHistoricalNomination = true;
}
break;
}
}
return(isHistoricalNomination);
}
private bool IsHistoricalNomination(Nomination nomination)
{
bool isHistoricalNomination = false;
var currentNomination = nomination;
var award = _encourageDatabaseContext.Query <Award>().FirstOrDefault(n => n.Id == currentNomination.AwardId);
var nominationDate = currentNomination.NominationDate;
var toBeComparedDate = _customDateService.GetCustomDate(currentNomination.AwardId);
if (award != null)
{
switch (award.Code)
{
default:
case "SOM":
if (nominationDate.Value != toBeComparedDate)
{
isHistoricalNomination = true;
}
break;
case "PINNACLE":
if (nominationDate.Value.Year != toBeComparedDate.Year)
{
isHistoricalNomination = true;
}
break;
}
}
return(isHistoricalNomination);
}
private static ContactPerson MapContactPerson(Nomination source)
{
return(new ContactPerson
{
FullName = $"{source.FirstName} {source.Surname}"
});
}
private static List <Address> MapAddresses(Nomination source)
{
var addressses = new List <Address>
{
new Address
{
Usage = MappingConstants.AddressUsageResidential,
Line1 = $"{source.AddressLine1} {source.AddressLine2}",
LocalityName = source.City,
StateTerritory = source.State,
PostCode = source.Postcode,
CountryName = MappingConstants.AddressCountryName,
}
};
if (!string.IsNullOrWhiteSpace(source.PostalAddressLine1))
{
addressses.Add(new Address
{
Usage = MappingConstants.AddressUsagePostal,
Line1 = $"{source.PostalAddressLine1} {source.PostalAddressLine2}",
LocalityName = source.PostalCity,
StateTerritory = source.PostalState,
PostCode = source.PostalPostcode,
CountryName = MappingConstants.AddressCountryName,
});
}
return(addressses.Any() ? addressses : null);
}
public IActionResult status(ViewNomVM model)
{
Nomination current = _db.Nomination.Where(a => a.NominationId == model.Nomination.NominationId).Include(a => a.University).FirstOrDefault();
current.StatusOfNomination = model.Nomination.StatusOfNomination;
_db.SaveChanges();
return(RedirectToAction("view", "nomination", new { id = model.Nomination.NominationId }));
}
private static List <GivenName> MapGivenName(Nomination source)
{
return(new List <GivenName> {
new GivenName {
SequenceNumber = 1, Name = source.FirstName
}
});
}
public ActionResult DeleteConfirmed(int id)
{
Nomination nomination = db.Nominations.Find(id);
db.Nominations.Remove(nomination);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private static SpecifiedPerson MapSpecifiedPerson(Nomination source) => new SpecifiedPerson
{
ContactInternet = MapContactInternet(source),
ContactTelephone = MapContactTelephone(source),
Address = MapAddresses(source),
BirthDate = source.DOB,
SpecifiedPersonName = MapSpecifiedPersonName(source),
Communication = MapCommunications()
};
private static List <SpecifiedPersonName> MapSpecifiedPersonName(Nomination source) => new List <SpecifiedPersonName>
{
new SpecifiedPersonName
{
GivenName = MapGivenName(source),
FamilyName = source.Surname,
UsageType = SpecifiedPersonNameUsageType.LGL
}
};
public ActionResult Details(int id = 0)
{
Nomination nomination = db.Nominations.Find(id);
if (nomination == null)
{
return(HttpNotFound());
}
return(View(nomination));
}
public Nomination Veto([FromBody] Nomination nomination)
{
return(new Nomination
{
Id = 1,
Vetoes = 0,
Name = "vetoed",
Approves = 0
});
}
public Nomination Post([FromBody] Nomination nomination)
{
return(new Nomination
{
Id = 99,
Vetoes = 0,
Name = nomination.Name,
Approves = 0
});
}
public ActionResult Create(Nomination nomination, FormCollection form)
{
nomination.Added = DateTime.Now;
nomination.Confirmed = false;
nomination.ConfirmationDate = DateTime.Now;
nomination.Emailed = nomination.Published;
nomination.EmailDate = DateTime.Now;
nomination.PublishDate = DateTime.Now;
foreach (var Nominated in nomination.Nominateds)
{
Nominated.Confirmed = false;
Nominated.ConfirmedDate = DateTime.Now;
Nominated.HashConfirmation = nomination.GetCode();
}
if (ModelState.IsValid)
{
nomination.HashConfirmation = nomination.GetCode();
Unit.NominationRepository.Insert(nomination);
this.InformGameAboutNomination(nomination);
Unit.Save();
if (nomination.Emailed && this.GetConfigValue("SendEmails") == "1" && this.GetConfigValue("SendNominationsEmail") == "1")
{
SendConfirmationMessages(nomination);
}
return RedirectToAction("Index");
}
return View(nomination);
}
public ActionResult Edit(Nomination nomination, FormCollection form)
{
if (ModelState.IsValid)
{
List<Nominated> NewNominateds = nomination.Nominateds as List<Nominated>;
List<Nominated> ExistingNominateds = Unit.NominatedRepository.Get(filter: n => n.NominationId == nomination.Id).ToList();
Nomination NewNomination = Unit.NominationRepository.GetById(nomination.Id);
foreach (Nominated n in ExistingNominateds)
{
Unit.NominatedRepository.Delete(n);
}
foreach (Nominated n in NewNominateds)
{
n.Confirmed = false;
n.ConfirmedDate = DateTime.Now;
n.HashConfirmation = NewNomination.GetCode();
NewNomination.Nominateds.Add(n);
}
NewNomination.Note = nomination.Note;
NewNomination.Published = nomination.Published;
NewNomination.Emailed = nomination.Published;
NewNomination.Confirmed = false;
NewNomination.HashConfirmation = NewNomination.GetCode();
if (nomination.Published)
{
NewNomination.PublishDate = DateTime.Now;
}
Unit.NominationRepository.Update(NewNomination);
this.InformGameAboutNomination(nomination);
Unit.Save();
if (NewNomination.Emailed)
{
SendConfirmationMessages(NewNomination);
}
return RedirectToAction("Index");
}
//ViewBag.TournamentId = new SelectList(db.Tournaments, "Id", "Name", nomination.TournamentId);
return View(nomination);
}
private Event CreateEvent(Nomination nomination)
{
Event Event = new Event();
if (nomination.GameId != null)
{
Event.Parse(nomination.Game, "game");
}
else
{
Event.Parse(nomination.Tournament, "tournament");
}
return Event;
}
/// <summary>
/// Sends information to Game object that nomination is created or not
/// </summary>
/// <param name="nomination">Nomination object</param>
/// <param name="isCreated">true - if nomination is created, false - if nomination is deleted</param>
private void InformGameAboutNomination(Nomination nomination, Boolean isCreated = true)
{
if (nomination.GameId != null)
{
var Game = Unit.GameRepository.GetById(nomination.GameId);
Game.NominationCreated = isCreated;
Unit.GameRepository.Update(Game);
}
}
/// <summary>
/// Wysyła potwierdzenia do sędziów o zrobionych obsadach
/// </summary>
/// <param name="nomination">Nominacja</param>
private void SendConfirmationMessages(Nomination nomination)
{
foreach (var Nominated in nomination.Nominateds)
{
var rf = Unit.RefereeRepository.GetById(Nominated.RefereeId);
NominationMessage nm = new NominationMessage()
{
Type = nomination.GameId != null ? "game" : "tournament",
NominationId = nomination.Id,
HashConfirmation = Nominated.HashConfirmation,
Mailadr = rf.Mailadr,
RefereeId = Nominated.RefereeId
};
MailHelper.CreateNominationMessage(nm);
}
}
