public async Task <ActionResult <Candidature> > PostCandidature(Candidature candidature)
{
candidature.Candidate = await _context.Candidate.FindAsync(candidature.CandidateId);
candidature.Status = await _context.Status.FindAsync(candidature.StatusId);
if (candidature.Candidate != null)
{
candidature.Candidate.User = await _context.User.FindAsync(candidature.Candidate.UserId);
candidature.Candidate.Country = await _context.Country.FindAsync(candidature.Candidate.CountryId);
candidature.Candidate.SalaryWish = await _context.SalaryWish.FindAsync(candidature.Candidate.SalaryWishId);
candidature.Candidate.DrivingLicence = await _context.DrivingLicence.FindAsync(candidature.Candidate.DrivingLicenceId);
}
candidature.JobOffer = await _context.JobOffer.FindAsync(candidature.JobOfferId);
candidature.JobOffer.Country = await _context.Country.FindAsync(candidature.JobOffer.CountryId);
candidature.JobOffer.Diploma = await _context.Diploma.FindAsync(candidature.JobOffer.DiplomaId);
candidature.JobOffer.Experience = await _context.Experience.FindAsync(candidature.JobOffer.ExperienceId);
candidature.JobOffer.ContratType = await _context.ContratType.FindAsync(candidature.JobOffer.ContratTypeId);
candidature.JobOffer.Domain = await _context.Domain.FindAsync(candidature.JobOffer.DomainId);
_context.Candidature.Add(candidature);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetCandidature", new { id = candidature.Id }, candidature));
}
public async Task ShouldBeHttpStatusCodeOk()
{
// Arrange
var ownerId = new UserId();
var clan = new Clan("ClanName", ownerId);
var candidature = new Candidature(new UserId(), clan.Id);
var factory = TestHost.WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, ownerId.ToString()));
_httpClient = factory.CreateClient();
var testServer = factory.Server;
testServer.CleanupDbContext();
await testServer.UsingScopeAsync(
async scope =>
{
var clanRepository = scope.GetRequiredService <IClanRepository>();
clanRepository.Create(clan);
await clanRepository.UnitOfWork.CommitAsync();
var candidatureRepository = scope.GetRequiredService <ICandidatureRepository>();
candidatureRepository.Create(candidature);
await candidatureRepository.UnitOfWork.CommitAsync();
});
// Act
using var response = await this.ExecuteAsync(candidature.Id);
// Assert
response.EnsureSuccessStatusCode();
response.StatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task <IActionResult> PutCandidature(int id, Candidature candidature)
{
if (id != candidature.Id)
{
return(BadRequest());
}
_context.Entry(candidature).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CandidatureExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <DomainValidationResult <Candidature> > SendCandidatureAsync(UserId userId, ClanId clanId)
{
var result = new DomainValidationResult <Candidature>();
if (await _clanRepository.IsMemberAsync(userId))
{
result.AddFailedPreconditionError("User already in a clan.");
}
if (await _candidatureRepository.ExistsAsync(userId, clanId))
{
result.AddFailedPreconditionError("The candidature of this member for that clan already exist.");
}
if (result.IsValid)
{
var candidature = new Candidature(userId, clanId);
_candidatureRepository.Create(candidature);
await _candidatureRepository.UnitOfWork.CommitAsync();
return(candidature);
}
return(result);
}
public async Task <ActionResult> Create([Bind(Include = "ID,Texte,Title")] Candidature candidature, int Id)
{
if (ModelState.IsValid)
{
string id = User.Identity.GetUserId();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var user = await UserManager.FindByIdAsync(id);
if (user == null)
{
return(HttpNotFound());
}
string emailAddress = user.Email;
ServiceProvider sp = new ServiceProvider();
sp = db.ServiceProviders.Where(x => x.Email == emailAddress).FirstOrDefault();
sp.Candidatures.Add(candidature);
Mission mis = db.Missions.Where(x => x.ID == Id).FirstOrDefault();
candidature.Mission = mis;
db.Candidatures.Add(candidature);
db.SaveChanges();
return(RedirectToAction("Index", "Missions"));
}
return(View(candidature));
}
/// <summary>
/// accept an application
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
public ActionResult AppAccept(int?Id)
{
if (Id == null)
{
return(View("Error"));
}
Candidature cd = db.Candidatures.Find(Id);
if (cd.State == State.Acceptée)
{
ViewBag.message = " Candidature déja accepté , On a notifié le prestataire";
}
if (cd.State == State.Rejetée)
{
ViewBag.message = "Candidature déja Rejeté : vous ppouvez pas l'accepter maintenant ";
}
if (cd.State == State.En_Attente)
{
cd.State = State.Acceptée;
ViewBag.message = "Candidature accepté ! Le prestataire sera notifié ";
cd.Mission.State = Status.Fermée;
/*ajouté aujourdh'ui pour mes mission coté prestataire*/
cd.Mission.ServiceProvider = cd.ServiceProvider;
ServiceProvider sp = cd.ServiceProvider;
sp.Missions.Add(cd.Mission);
db.SaveChanges();
}
return(View());
}
public Candidature Edit(int id, [Bind("IdCandidature,PrenomCandidat,NomCandidat,EtatCandidature,CV,IdTicket")] Candidature can)
{
if (id != can.IdCandidature)
{
return(null);
}
if (ModelState.IsValid)
{
try
{
candidature.Update(can);
candidature.Save();
}
catch (DbUpdateConcurrencyException)
{
if (!CandidatureExists(can.IdCandidature))
{
return(null);
}
else
{
throw;
}
}
return(can);
}
return(can);
}
public async Task <ActionResult> Apply(int Id)
{
string id = User.Identity.GetUserId();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var user = await UserManager.FindByIdAsync(id);
if (user == null)
{
return(HttpNotFound());
}
string emailAddress = user.Email;
ServiceProvider sp = new ServiceProvider();
sp = db.ServiceProviders.Where(x => x.Email == emailAddress).FirstOrDefault();
if (sp == null)
{
return(Content("although you have access to service Provider Space , but you are not registered as Service Provider in Our dtabse , Please contact our Platform administrators for a quick Fix , Thanks!"));
}
Mission mis = db.Missions.Where(x => x.ID == Id).FirstOrDefault();
if (mis.Candidatures != null)
{
Candidature cd = mis.Candidatures.Where(x => x.ServiceProvider == sp).FirstOrDefault();
if (cd != null)
{
return(View("AlreadyApplied"));
}
}
return(View());
}
public async Task DeclineCandidatureAsync_ShouldBeOfTypeValidationResult()
{
// Arrange
var candidature = new Candidature(new UserId(), new ClanId());
TestMock.ClanRepository.Setup(repository => repository.IsOwnerAsync(It.IsAny <ClanId>(), It.IsAny <UserId>())).ReturnsAsync(true).Verifiable();
TestMock.CandidatureRepository.Setup(repository => repository.Delete(It.IsAny <Candidature>())).Verifiable();
TestMock.CandidatureRepository.Setup(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
var service = new CandidatureService(TestMock.CandidatureRepository.Object, TestMock.ClanRepository.Object);
// Act
var result = await service.DeclineCandidatureAsync(candidature, new UserId());
// Assert
result.Should().BeOfType <DomainValidationResult <Candidature> >();
TestMock.ClanRepository.Verify(repository => repository.IsOwnerAsync(It.IsAny <ClanId>(), It.IsAny <UserId>()), Times.Once);
TestMock.CandidatureRepository.Verify(repository => repository.Delete(It.IsAny <Candidature>()), Times.Once);
TestMock.CandidatureRepository.Verify(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task <ActionResult> Apply([Bind(Include = "ID,Texte,Title")] Candidature candidature, int Id)
{
if (ModelState.IsValid)
{
string id = User.Identity.GetUserId();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var user = await UserManager.FindByIdAsync(id);
if (user == null)
{
return(HttpNotFound());
}
string emailAddress = user.Email;
ServiceProvider sp = new ServiceProvider();
sp = db.ServiceProviders.Where(x => x.Email == emailAddress).FirstOrDefault();
if (sp == null)
{
return(Content("although you have access to service Provider Space , but you are not registered as Service Provider in Our dtabse , Please contact our Platform administrators for a quick Fix , Thanks!"));
}
sp.Candidatures.Add(candidature);
Mission mis = db.Missions.Where(x => x.ID == Id).FirstOrDefault();
candidature.ServiceProvider = sp;
candidature.Mission = mis;
candidature.AppDate = DateTime.Today;
candidature.State = State.En_Attente;
db.Candidatures.Add(candidature);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(candidature));
}
public ActionResult Create(Guid id)
{
var user = GetCurrentUser();
var assessment = Db.Assessments.SingleOrDefault(x => x.Id == id);
var candidature =
Db.Candidatures.SingleOrDefault(x => x.Assessment.Id == assessment.Id && x.UserId.Equals(user.Id));
if (candidature == null)
{
return(View(assessment));
candidature = new Candidature
{
Assessment = assessment,
Joined = DateTime.Now,
UserId = user.Id,
};
Db.Candidatures.Add(candidature);
Db.SaveChanges();
}
return(RedirectToAction("MyRoom", new { id = candidature.Id }));
}
public async void ShowEtatDeLaCandidature()
{
if (lvCandidaturesCandidat.SelectedItem != null)
{
Candidature laCandidatureChoisie = lvCandidaturesCandidat.SelectedItem as Candidature;
if (laCandidatureChoisie.StatutMessage == "En attente")
{
var message = new MessageDialog("Cette candidature est encore en attente, le recruteur du restaurant "
+ laCandidatureChoisie.LeResto.LibelleResto + " n'a pas encore examiné votre candidature.");
await message.ShowAsync();
}
else if (laCandidatureChoisie.StatutMessage == "En cours")
{
var message = new MessageDialog("Cette candidature est encore en cours d'examen, le recruteur du restaurant "
+ laCandidatureChoisie.LeResto.LibelleResto + " est entrain de l'étudier.");
await message.ShowAsync();
}
else if (laCandidatureChoisie.StatutMessage == "Refusée")
{
var message = new MessageDialog(laCandidatureChoisie.MessageReponse);
await message.ShowAsync();
}
else if (laCandidatureChoisie.StatutMessage == "Acceptée")
{
var message = new MessageDialog(laCandidatureChoisie.MessageReponse);
await message.ShowAsync();
}
}
else
{
var message = new MessageDialog("Veuillez sélectionner une candidature");
await message.ShowAsync();
}
}
public ActionResult DeleteConfirmed(int id)
{
Candidature candidature = db.Candidatures.Find(id);
db.Candidatures.Remove(candidature);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult AppEdit([Bind(Include = "ID,Texte,Title,State")] Candidature candidature)
{
if (ModelState.IsValid)
{
db.Entry(candidature).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Candidatures"));
}
return(View(candidature));
}
public async Task <bool> SetNouveauStatutCandidature(string statut)
{
bool ModifierLeStatut = false;
if (lvCandidatures.SelectedItem != null)
{
Candidature laCandidChoisie = lvCandidatures.SelectedItem as Candidature;
Restaurant leRestoChoisi = laCandidChoisie.LeResto;
Poste lePosteChoisi = laCandidChoisie.LePosteVoulu;
Utilisateur lutilisateur = laCandidChoisie.LeCandidat;
ContentDialog ChangeStatutCandidatureDialog = new ContentDialog
{
Title = "Bonjour !",
Content = "Voulez-vous vraiment modifier le statut de la candidature de " + lutilisateur.FullName +
"au restaurant " + leRestoChoisi.LibelleResto + " au poste de " + lePosteChoisi.LibellePoste + " ?",
PrimaryButtonText = "Oui",
CloseButtonText = "Non"
};
ContentDialogResult result = await ChangeStatutCandidatureDialog.ShowAsync();
// Modifie la candidature si l'utilisateur a cliqué sur le bouton principal ("oui")
// Sinon, rien faire.
if (result == ContentDialogResult.Primary)
{
//action=updateCandidatureStatut&idCandidature={idCandidature}&new_statut={new_statut}
string idCandidature = laCandidChoisie.IdCandidature.ToString();
var reponse = await hc.GetStringAsync("http://localhost/recru_eatgood_api/index_recruteur.php?" +
"action=updateCandidatureStatut" +
"&idCandidature=" + idCandidature +
"&new_statut=" + statut);
var donneesJson = JsonConvert.DeserializeObject <dynamic>(reponse);
var resultat = donneesJson["Success"];
if (resultat == "true")
{
await lesDonnees.SetAllCandidature();
this.Frame.Navigate(typeof(Page_R_Accueil), lesDonnees);
ModifierLeStatut = true;
}
else if (resultat == "false")
{
var message = new MessageDialog("Cette candidature n'existe pas. Ou alors il y a une erreur dans le code");
await message.ShowAsync();
}
}
}
else
{
var message = new MessageDialog("! Avant de modifier le statut d'une candidature, il faut d'abord en selectionner une !");
await message.ShowAsync();
}
return(ModifierLeStatut);
}
public ActionResult TextInput(Candidature model)
{
var candidature = Db.Candidatures.SingleOrDefault(x => x.Id == model.Id);
candidature.Characteristics = model.Characteristics;
candidature.Motivation = model.Motivation;
Db.SaveChanges();
return(RedirectToAction("MyRoom", new { id = candidature.Id }));
}
/// <summary>
/// Get the situation of hiw app ( accepted , rejected or waiting)
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult state(int?id)
{
if (id == null)
{
ViewBag.popup = "Une erreur survenu durant la procédure , essayez de nouveau dans quelques minutes";
return(View("popup"));
}
Candidature cd = db.Candidatures.Find(id);
ViewBag.popup = "Votre candidature est " + cd.State.ToString();
return(View("popup"));
}
public ActionResult Send(int?id)
{
if (id == null)
{
return(View("Error"));
}
Candidature cr = db.Candidatures.Find(id);
ServiceProvider sp = cr.ServiceProvider;
TempData["sp"] = sp;
return(View());
}
public ActionResult DeleteApp(int Id)
{
try
{
Candidature cd = db.Candidatures.Find(Id);
db.Candidatures.Remove(cd);
db.SaveChanges();
return(Content(Boolean.TrueString));
}
catch
{
return(Content(Boolean.FalseString));
}
}
public ActionResult AppEdit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Candidature ca = db.Candidatures.Find(id);
if (ca == null)
{
return(HttpNotFound());
}
return(View(ca));
}
public async Task <Candidature> GetCandidature(int Id)
{
_oCandidature = new Candidature();
using (var httpClient = new HttpClient(_clientHandler))
{
using (var response = await httpClient.GetAsync("https://localhost:44304/api/Candidatures/" + Id))
{
string apiResponse = await response.Content.ReadAsStringAsync();
_oCandidature = JsonConvert.DeserializeObject <Candidature>(apiResponse);
}
}
return(_oCandidature);
}
public ActionResult <Candidature> DeleteConfirmed(int id)
{
Candidature _candidature = candidature.GetById(id);
if (_candidature != null)
{
candidature.Delete(_candidature.IdCandidature);
candidature.Save();
return(RedirectToAction("Index"));
}
else
{
return(NotFound());
}
}
public IEnumerable <Candidature> Create([Bind("IdCandidature,PrenomCandidat,NomCandidat,EtatCandidature,CV,IdTicket")] Candidature can)
{
IEnumerable <Candidature> candidatures = candidature.GetAll();
if (ModelState.IsValid && !(CandidatureExists(can.IdCandidature)))
{
candidature.Insert(can);
candidature.Save();
return(candidatures);
}
else
{
return(null);
}
}
public async Task <Candidature> PostCandidature(Candidature Candidature)
{
_oCandidature = new Candidature();
using (var httpClient = new HttpClient(_clientHandler))
{
StringContent content = new StringContent(JsonConvert.SerializeObject(Candidature), Encoding.UTF8, "application/json");
using (var response = await httpClient.PostAsync("https://localhost:44304/api/Candidatures", content))
{
string apiResponse = await response.Content.ReadAsStringAsync();
_oCandidature = JsonConvert.DeserializeObject <Candidature>(apiResponse);
}
}
return(_oCandidature);
}
public ActionResult App_Details(int?id)
{
if (Request.IsAjaxRequest())
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Candidature ca = db.Candidatures.Where(x => x.ID == id).FirstOrDefault();
if (ca == null)
{
return(HttpNotFound());
}
return(PartialView(ca));
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public async Task Handle()
{
// Arrange
TestMock.ClanService.Setup(service => service.AddMemberToClanAsync(It.IsAny <ClanId>(), It.IsAny <IMemberInfo>()))
.Returns(Task.CompletedTask)
.Verifiable();
var domainEventHandler = new CandidatureAcceptedDomainEventHandler(TestMock.ClanService.Object);
var candidature = new Candidature(new UserId(), new ClanId());
// Act
await domainEventHandler.Handle(new CandidatureAcceptedDomainEvent(candidature), CancellationToken.None);
// Assert
TestMock.ClanService.Verify(service => service.AddMemberToClanAsync(It.IsAny <ClanId>(), It.IsAny <IMemberInfo>()), Times.Once);
}
public void Contructor_Tests()
{
// Arrange
var userId = new UserId();
var clanId = new ClanId();
// Act
var candidature = new Candidature(userId, clanId);
// Assert
candidature.Id.Should().BeOfType(typeof(CandidatureId));
candidature.UserId.Should().Be(userId);
candidature.UserId.Should().NotBeNull();
candidature.ClanId.Should().Be(clanId);
candidature.ClanId.Should().NotBeNull();
}
public async Task AcceptCandidatureAsync_WhenNotOwner_ShouldBeOfTypeValidationResultWithErrors()
{
// Arrange
var candidature = new Candidature(new UserId(), new ClanId());
TestMock.ClanRepository.Setup(repository => repository.IsOwnerAsync(It.IsAny <ClanId>(), It.IsAny <UserId>())).ReturnsAsync(false).Verifiable();
var service = new CandidatureService(TestMock.CandidatureRepository.Object, TestMock.ClanRepository.Object);
// Act
var result = await service.AcceptCandidatureAsync(candidature, new UserId());
// Assert
result.Should().BeOfType <DomainValidationResult <Candidature> >();
result.Errors.Should().NotBeEmpty();
TestMock.ClanRepository.Verify(repository => repository.IsOwnerAsync(It.IsAny <ClanId>(), It.IsAny <UserId>()), Times.Once);
}
private async void btnMessageReponse_Click(object sender, RoutedEventArgs e)
{
if (lvCandidatures.SelectedItem != null)
{
Candidature laCandidChoisie = lvCandidatures.SelectedItem as Candidature;
Restaurant leRestoChoisi = laCandidChoisie.LeResto;
Poste lePosteChoisi = laCandidChoisie.LePosteVoulu;
Utilisateur lutilisateur = laCandidChoisie.LeCandidat;
if (laCandidChoisie.StatutMessage == "En attente")
{
var message = new MessageDialog("Vous ne pouvez pas modifier le message d'une candidature qui n'est pas : en cours de traitement ou déjà traitée");
await message.ShowAsync();
}
else
{
ContentDialog ChangeStatutCandidatureDialog = new ContentDialog
{
Title = "Bonjour !",
Content = "Voulez-vous vraiment modifier le message de la candidature de " + lutilisateur.FullName +
"au restaurant " + leRestoChoisi.LibelleResto + " au poste de " + lePosteChoisi.LibellePoste + " ?",
PrimaryButtonText = "Oui",
CloseButtonText = "Non"
};
ContentDialogResult result = await ChangeStatutCandidatureDialog.ShowAsync();
// Modifie la candidature si l'utilisateur a cliqué sur le bouton principal ("oui")
// Sinon, rien faire.
if (result == ContentDialogResult.Primary)
{
SetMessageCandidature(laCandidChoisie, "Traitée");
}
}
}
else
{
var message = new MessageDialog("! Avant de modifier le message d'une candidature, il faut d'abord en selectionner une !");
await message.ShowAsync();
}
}
public async Task Handle()
{
// Arrange
TestMock.ClanService.Setup(service => service.FindClanAsync(It.IsAny <ClanId>())).ReturnsAsync(new Clan("test", new UserId())).Verifiable();
TestMock.ServiceBusPublisher.Setup(bus => bus.PublishAsync(It.IsAny <ClanCandidatureSentIntegrationEvent>()))
.Returns(Task.CompletedTask)
.Verifiable();
var domainEventHandler = new CandidatureCreatedDomainEventHandler(TestMock.ClanService.Object, TestMock.ServiceBusPublisher.Object);
var candidature = new Candidature(new UserId(), new ClanId());
// Act
await domainEventHandler.Handle(new CandidatureCreatedDomainEvent(candidature), CancellationToken.None);
// Assert
TestMock.ClanService.Verify(service => service.FindClanAsync(It.IsAny <ClanId>()), Times.Once);
TestMock.ServiceBusPublisher.Verify(bus => bus.PublishAsync(It.IsAny <ClanCandidatureSentIntegrationEvent>()), Times.Once);
}
