/// <summary>
/// Invoked when <see cref="ToDTO"/> operation is about to return.
/// </summary>
/// <param name="dto"><see cref="PhoneDTO"/> converted from <see cref="Phone"/>.</param>
static partial void OnDTO(this Experience entity, ExperienceDTO dto)
{
if (entity != null && entity.Business != null)
{
dto.Business = BusinessAssembler.ToDTO(entity.Business);
}
}
public async Task <List <ExperienceDTO> > buildExperience(int cvId)
{
List <ExperienceDTO> experienceList = new List <ExperienceDTO>();
List <Experience> experience = await dbContext.Experience.Include(p => p.SkillsExperience).Where(p => p.CvId == cvId).OrderByDescending(p => p.DateFrom).ToListAsync();
foreach (Experience expr in experience)
{
List <string> skills = dbContext.SkillsExperience.Where(p => p.ExperienceId == expr.Id).Select(p => p.Skills.Label).ToList();
List <TasksDTO> tasks = dbContext.Tasks.Where(p => p.ExperienceId == expr.Id).Select(p => new TasksDTO
{
Label = p.Label
}).ToList();
ExperienceDTO buildExperience = new ExperienceDTO
{
Company = expr.Company,
DateFrom = expr.DateFrom,
DateTo = expr.DateTo,
Title = expr.Title,
Skills = skills,
Tasks = tasks,
};
experienceList.Add(buildExperience);
}
return(experienceList);
}
public void CreateExperience(ExperienceDTO experience)
{
var mapped = _mapper.Map <Experience>(experience);
_context.ExperienceEntities.Add(mapped);
_context.SaveChangesAsync();
}
public async Task <IActionResult> postExperience(ExperienceDTO input)
{
var user = await userManager.FindByIdAsync(input.userID);
if (input.newExperience)
{
if (user.Experiences == null)
{
user.Experiences = new List <Experience>();
}
user.Experiences.Add(new Experience
{
Title = input.title,
Assignments = input.Assignments,
Language = input.Language,
Role = input.Role,
StartDate = input.startDate,
EndDate = input.endDate,
Software = input.Software,
id = input.id
});
}
else
{
for (int i = 0; i < user.Experiences.Count; i++)
{
}
}
await userManager.UpdateAsync(user);
return(Ok(user.Experiences));
}
public void EditExperience(ExperienceDTO experienceDTO)
{
if (experienceDTO == null)
{
throw new ArgumentNullException(nameof(experienceDTO));
}
Experience experience = Database.Experiences.Get(experienceDTO.Id);
if (experience == null)
{
throw new ArgumentOutOfRangeException("Not found experience");
}
Resume resume = Database.Resumes.Get(experienceDTO.ResumeId);
if (resume == null)
{
throw new ArgumentOutOfRangeException("Invalid argument ResumeId");
}
experience.ResumeId = experienceDTO.ResumeId;
experience.Company = experienceDTO.Company;
experience.LastPosition = experienceDTO.LastPosition;
experience.StartDate = experienceDTO.StartDate;
experience.FinishDate = experienceDTO.FinishDate;
experience.Resume = resume;
Database.Experiences.Update(experience);
Database.Save();
}
public async Task <Result <SkillsDTO> > GetUserSkills(string userId)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(Result <SkillsDTO> .CreateFailed(
HttpStatusCode.NotFound, "User not found"));
}
var expiriences = await _context.Experiences.Where(x => x.User == user).ToListAsync();
var educations = await _context.Educations.Where(x => x.User == user).ToListAsync();
var personalSkills = await _context.PersonalSkills.Where(x => x.User == user).ToListAsync();
var a = Result <SkillsDTO> .CreateSuccessful(
new SkillsDTO(
ExperienceDTO.ToExperienceDTOList(expiriences),
EducationDTO.ToEducationDTOList(educations),
PersonalSkillDTO.ToPersonalSkillDTOList(personalSkills)
));
return(a);
}
public IHttpActionResult PutExperience(int id, ExperienceDTO experience)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != experience.ExperienceID)
{
return(BadRequest());
}
try
{
db.Create(experience);
}
catch (DbUpdateConcurrencyException)
{
if (!ExperienceExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task CreateAsync(ExperienceDTO experienceDTO)
{
// if no Job is provided
if (experienceDTO.Job == null)
{
throw new ArgumentNullException(nameof(experienceDTO.Job));
}
var adminRoleId = this.roles.AllAsNoTracking().FirstOrDefault(x => x.Name == GlobalConstants.AdministratorRoleName).Id;
var user = this.users.All().FirstOrDefault(x => x.Roles.Any(x => x.RoleId == adminRoleId));
var experience = new Experience
{
Job = experienceDTO.Job.Trim(),
Company = experienceDTO.Company.Trim(),
Url = experienceDTO.Url.Trim(),
Logo = experienceDTO.Logo.Trim(),
StartDate = DateTime.Parse(experienceDTO.StartDate.Trim(), CultureInfo.InvariantCulture).Date,
EndDate = DateTime.Parse(experienceDTO.EndDate.Trim(), CultureInfo.InvariantCulture).Date,
IconClassName = experienceDTO.IconClassName.Trim(),
Details = experienceDTO.Details.Trim(),
UserId = user.Id,
};
await this.experiencesRepository.AddAsync(experience);
await this.experiencesRepository.SaveChangesAsync();
}
public void Add(ExperienceDTO DTO)
{
using (var container = new InventoryContainer())
{
EmpExperienceInfo gur = new EmpExperienceInfo();
container.EmpExperienceInfoes.AddObject((EmpExperienceInfo)DTOMapper.DTOObjectConverter(DTO, gur));
container.SaveChanges();
}
}
public ExperienceDTO Create(ExperienceDTO modelDTO)
{
if (modelDTO != null)
{
return(ExperienceAssembler.ToDTO(ExperiencesRepo.Create(ExperienceAssembler.ToEntity(modelDTO))));
}
return(null);
}
public void EditExperience_NullElement_ShouldThrowException()
{
//arrange
var experience = new ExperienceDTO {
Id = It.IsAny <int>()
};
//act & assert
NUnit.Framework.Assert.Throws <ArgumentOutOfRangeException>(() => expService.EditExperience(experience));
}
public void Update(ExperienceDTO experienceDTO)
{
Company = experienceDTO.Company;
StartDate = experienceDTO.StartDate;
EndDate = experienceDTO.EndDate;
Link = experienceDTO.Link;
StillThere = experienceDTO.StillThere;
Title = experienceDTO.Title;
Description = experienceDTO.Description;
IsPublic = experienceDTO.IsPublic;
}
public IHttpActionResult PostExperience(ExperienceDTO experience)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Create(experience);
return(CreatedAtRoute("DefaultApi", new { id = experience.ExperienceID }, experience));
}
public IHttpActionResult GetExperience(int id)
{
ExperienceDTO experience = db.Get(id);
if (experience == null)
{
return(NotFound());
}
return(Ok(experience));
}
public ExperienceDTO Update(ExperienceDTO modelDTO)
{
ExperienceDTO returnExperience = null;
if (modelDTO != null && modelDTO.ExperienceID > 0)
{
ExperiencesRepo.Update(0, ExperienceAssembler.ToEntity(modelDTO));
returnExperience = modelDTO;
}
return(returnExperience);
}
public Experience ConvertToEF(ExperienceDTO DTO)
{
var EF = new Experience()
{
ExperienceId = DTO.ExperienceId,
EMax = DTO.EMax,
EMin = DTO.EMin,
EShow = DTO.EShow
};
return(EF);
}
public void CreateExperience_TryToCreateExperience_ShouldRepositoryCreateOnce()
{
var Experience = new ExperienceDTO {
Id = It.IsAny <int>(), ResumeId = It.IsAny <int>()
};
// act
expService.CreateExperience(Experience);
//assert
expRepository.Verify(x => x.Create(It.IsAny <Experience>()));
}
public ExperienceDTO ConvertToDTO(Experience EF)
{
var DTO = new ExperienceDTO()
{
ExperienceId = EF.ExperienceId,
EMax = EF.EMax,
EMin = EF.EMin,
EShow = EF.EShow
};
return(DTO);
}
public IActionResult UpdateUserExperience(Guid id, Guid experienceId, [FromBody] ExperienceDTO experience)
{
try
{
experience.UserID = id;
experience.ExperienceID = experienceId;
_userExperienceService.UpdateExperience(experienceId, experience);
return(NoContent());
}
catch (Exception e)
{
return(_handler.HandleError(e));
}
}
public void CreateExperience_StateUnderTest_ExpectedBehavior()
{
// Arrange
var service = this.CreateService();
ExperienceDTO experience = null;
// Act
//service.CreateExperience(
// experience);
// Assert
Assert.True(true);
this.mockRepository.VerifyAll();
}
public ExperienceDTO Get(int id)
{
ExperienceDTO oExperienceDTO = null;
if (id > 0)
{
Experience oExperience = ExperiencesRepo.Get(id);
if (oExperience != null)
{
oExperienceDTO = ExperienceAssembler.ToDTO(oExperience);
}
}
return(oExperienceDTO);
}
public void RemoveExperience(ExperienceDTO experienceDTO)
{
if (experienceDTO == null)
{
throw new ArgumentNullException(nameof(experienceDTO));
}
if (Database.Experiences.Get(experienceDTO.Id) == null)
{
throw new ArgumentOutOfRangeException("Not found experience");
}
Database.Experiences.Delete(experienceDTO.Id);
Database.Save();
}
public async Task <ActionResult <ExperienceDTO> > PostExperience(ExperienceDTO experienceDTO)
{
Experience sanitizedExperience = DTOToExperience(experienceDTO);
if (!await ResumeAccessAuthorized(sanitizedExperience.ResumeId))
{
return(GenerateResumeNotFoundError(sanitizedExperience.ResumeId));
}
_context.Experiences.Add(sanitizedExperience);
await _context.SaveChangesAsync();
return(CreatedAtAction("PostExperience", new { resumeId = sanitizedExperience.ResumeId, order = sanitizedExperience.Order }, experienceDTO));
}
public IHttpActionResult PostExperience(ExperienceDTO experience)
{
//experience = new ExperienceDTO();
//experience.BusinessID = 18;
//experience.JobPossition = "Software Developer";
//experience.UserID = 50;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var objExprience = db.Create(experience);
return(CreatedAtRoute("DefaultApi", new { id = experience.ExperienceID }, objExprience));
}
public async Task <IActionResult> removeExperience(ExperienceDTO input)
{
var user = await userManager.FindByIdAsync(input.userID);
for (int i = 0; i < user.Experiences.Count; i++)
{
if (user.Experiences[i].id == input.id)
{
user.Experiences.RemoveAt(i);
await userManager.UpdateAsync(user);
return(Ok(user.Experiences));
}
}
return(BadRequest());
}
public void UpdateExperience_StateUnderTest_ExpectedBehavior()
{
// Arrange
var service = this.CreateService();
Guid id = default(global::System.Guid);
ExperienceDTO experience = null;
// Act
//service.UpdateExperience(
// id,
// experience);
// Assert
Assert.True(true);
this.mockRepository.VerifyAll();
}
public ActionResult Edit(ExperienceViewModel model)
{
var experienceDTO = new ExperienceDTO
{
Id = model.Id,
CompanyName = model.CompanyName.Trim(),
CountExperience = model.CountExperience.Trim(),
CityId = model.CityId,
KnowledgeId = model.KnowledgeId,
UserId = model.UserId
};
experienceService.Update(experienceDTO);
return(RedirectToAction("Index"));
}
public void RemoveExperience_Delete()
{
var Experience = new ExperienceDTO {
Id = It.IsAny <int>(), Company = It.IsAny <string>()
};
expRepository.Setup(x => x.Get(It.IsAny <int>())).Returns(new Experience {
Id = It.IsAny <int>(), Company = It.IsAny <string>()
});
//act
expService.RemoveExperience(Experience);
//assert
expRepository.Verify(x => x.Delete(It.IsAny <int>()));
}
public void CreateUserExperience_StateUnderTest_ExpectedBehavior()
{
// Arrange
var usersController = this.CreateUsersController();
Guid id = default(global::System.Guid);
ExperienceDTO experience = new ExperienceDTO();
// Act
var result = usersController.CreateUserExperience(
id,
experience);
// Assert
Assert.True(true);
this.mockRepository.VerifyAll();
}
public async Task <Result <ExperienceDTO> > SaveExperience(string userId, ExperienceDTO experienceDTO)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(Result <ExperienceDTO> .CreateFailed(
HttpStatusCode.NotFound, "User not found"));
}
var expirience = await _context.Experiences.Where(x => x.User == user && x.Id == experienceDTO.Id).FirstOrDefaultAsync();
if (expirience != null)
{
expirience.Update(experienceDTO);
await _knnService.RemoveSkill(expirience, user);
}
else
{
expirience = new Experience();
expirience.Update(experienceDTO);
expirience.User = user;
await _context.Experiences.AddAsync(expirience);
}
if (expirience.StillThere == true)
{
user.CurrentState = expirience.Description + " at " + expirience.Company;
}
await _knnService.ManageSkill(expirience, user);
try
{
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(Result <ExperienceDTO> .CreateFailed(
HttpStatusCode.NotFound, "Error Changes are not saved"));;
}
return(Result <ExperienceDTO> .CreateSuccessful(new ExperienceDTO(expirience)));
}