public async Task <IActionResult> PutExperience(int id, [FromBody] ExperienceDto experienceDto)
{
if (experienceDto == null || experienceDto.ID != id)
{
return(BadRequest());
}
Experience updatedExperience = _mapper.Map <ExperienceDto, Experience>(experienceDto);
bool isOk = await TryUpdateModelAsync(updatedExperience);
if (!isOk || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Experience experience = await _experienceRepository.FindAsync(id);
if (experience == null)
{
return(NotFound());
}
experience.DateBegin = updatedExperience.DateBegin;
experience.DateEnd = updatedExperience.DateEnd;
experience.Description = updatedExperience.Description;
experience.ExperienceType_ID = updatedExperience.ExperienceType_ID;
_experienceRepository.Update(experience);
return(NoContent());
}
public async Task AddAuthorCommandHandler_WithExperiences_ReturnsAuthor()
{
var image = await AddImage();
var experiences = new List <ExperienceDto>();
var experienceDto = new ExperienceDto()
{
Color = "#000000",
Name = "Testfile",
ImageId = image.Id
};
experiences.Add(experienceDto);
var authorValidator = new AuthorValidator(RequestDbContext);
var addAuthorCommandHandler = new AddAuthorCommandHandler(TestContext.CreateHandlerContext <AuthorViewModel>(RequestDbContext, CreateMapper()), _userService, authorValidator);
var message = new AddAuthorCommand()
{
FirstName = "Tom", LastName = "Bina", About = "About me", Experiences = experiences
};
var result = await addAuthorCommandHandler.Handle(message, CancellationToken.None);
Assert.Equal("Testfile", result.Experiences.First().Name = experienceDto.Name);
}
public async Task <IActionResult> AddExperience(ExperienceDto experienceDto)
{
var experience = _mapper.Map <Experience>(experienceDto);
experience.UserId = UserId;
_context.Experiences.Add(experience);
await _context.SaveChangesAsync();
return(NoContent());
}
public IActionResult OnGet(int experienceId)
{
Experience = repository.GetExperienceById(experienceId);
if (Experience == null)
{
return(RedirectToPage("./NotFound"));
}
return(Page());
}
public async Task <IActionResult> EditExperienceAsync(Guid id, ExperienceDto experience)
{
var content = new StringContent(JsonConvert.SerializeObject(experience), System.Text.Encoding.UTF8, "application/json");
HttpResponseMessage response = await _oplevOgDelService.Client.PutAsync(_apiUrls.Experiences + $"/{id}", content);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("ManageExperience", new { id }));
}
return(RedirectToAction("EditExperience", new { id }));
}
public ExperienceDto UpdateExperience(ExperienceDto experienceDto)
{
if (experienceDto.Id <= 0)
{
return(null);
}
var experience = experienceDto.ToEntity();
var updated = _experienceDao.Update(experience);
_experienceDao.Commit();
return(updated.ToDto());
}
public bool InsertExperience(ExperienceDto experience)
{
return(_context.Experiences.Add(new Experience
{
UserId = experience.UserId,
Title = experience.Title,
Company = experience.Company,
Summary = experience.Summary,
Location = experience.Location,
StartDate = experience.StartDate,
EndDate = experience.EndDate,
IsCurrent = experience.IsCurrent,
CreateDate = DateTime.Now
}) != null);
}
private bool AddExperience(string userId, ExperienceViewModel experience)
{
var addRecord = new ExperienceDto()
{
UserId = userId,
Title = experience.Title,
Company = experience.Company,
Summary = experience.Summary,
Location = experience.Location,
StartDate = experience.StartDate,
EndDate = experience.EndDate,
IsCurrent = experience.IsCurrent
};
return(_experienceService.InsertExperience(userId, addRecord));
}
public bool UpdateExperience(string userId, ExperienceDto experience)
{
try
{
//Validate user
if (_userRepository.IsAuthenticated(userId))
{
var record = _experienceRepository.GetExperienceById(experience.Id.ToString());
if (record != null)
{
//Validate Model
ICollection <ValidationResult> results;
if (IsValidModel(experience, out results))
{
if (ModelCompareChecker.Compare(experience, record))
{
return(true);
}
record.Title = experience.Title;
record.Company = experience.Company;
record.Summary = experience.Summary;
record.Location = experience.Location;
record.StartDate = experience.StartDate;
record.EndDate = experience.EndDate;
record.IsCurrent = experience.IsCurrent;
//Call Repository
if (_experienceRepository.UpdateExperience(record))
{
return(true);
}
_loggingService.Info("UserRepository Failed Update");
}
_loggingService.Info("Model Validation Failed: " + experience);
}
}
_loggingService.Info("UserId Authenticated Failed: " + userId);
}
catch (Exception ex)
{
//Error
_loggingService.Error("An error has occurred", ex);
}
//Fail
return(false);
}
public async Task <ExperienceDto> CreateExperience(ExperienceDto model)
{
var entity = new Experience
{
Position = model.Position,
Company = model.Company,
Start = model.Start,
End = model.End,
Description = model.Description,
ProfileId = Constants.DefaultProfileId
};
dbContext.Experiences.Add(entity);
await dbContext.SaveChangesAsync();
return(ToExperienceDto(entity));
}
public IActionResult OnGet(int?experienceId)
{
if (experienceId.HasValue)
{
Experience = repository.GetExperienceById(experienceId.Value);
}
else
{
Experience = new ExperienceDto();
}
if (Experience == null)
{
return(RedirectToPage("/index"));
}
return(Page());
}
/// <summary>
/// Update a Experience content.
/// </summary>
/// <param name="body">The data of the content to be created or updated.
/// <param name="id">The id of the Experience content.</param>
/// <returns>ExperienceContentDto</returns>
public ExperienceContentDto UpdateExperienceContent(ExperienceDto body, string id)
{
// verify the required parameter 'body' is set
if (body == null)
{
throw new ApiException(400, "Missing required parameter 'body' when calling UpdateExperienceContent");
}
// verify the required parameter 'id' is set
if (id == null)
{
throw new ApiException(400, "Missing required parameter 'id' when calling UpdateExperienceContent");
}
var path = "/content/mycv/experience/{id}";
path = path.Replace("{format}", "json");
path = path.Replace("{" + "id" + "}", ApiClient.ParameterToString(id));
var queryParams = new Dictionary <String, String>();
var headerParams = new Dictionary <String, String>();
var formParams = new Dictionary <String, String>();
var fileParams = new Dictionary <String, FileParameter>();
String postBody = null;
postBody = ApiClient.Serialize(body); // http body (model) parameter
// authentication setting, if any
String[] authSettings = new String[] { "squidex-oauth-auth" };
// make the HTTP request
IRestResponse response = (IRestResponse)ApiClient.CallApi(path, Method.PUT, queryParams, postBody, headerParams, formParams, fileParams, authSettings);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling UpdateExperienceContent: " + response.Content, response.Content);
}
else if (((int)response.StatusCode) == 0)
{
throw new ApiException((int)response.StatusCode, "Error calling UpdateExperienceContent: " + response.ErrorMessage, response.ErrorMessage);
}
return((ExperienceContentDto)ApiClient.Deserialize(response.Content, typeof(ExperienceContentDto), response.Headers));
}
public List <ExperienceDto> Details(int id, int lid)
{
var details = _expRepository.GetAll().Include(x => x.Employe)
.Where(y => y.EmployeId == id && y.LanguageId == lid).ToList();
var list = new List <ExperienceDto>();
foreach (var detail in details)
{
var exp = new ExperienceDto();
exp.StartDate = detail.StartDate;
exp.EndDate = detail.EndDate;
exp.Description = detail.Description;
exp.Organisation = detail.Organisation;
list.Add(exp);
}
return(ObjectMapper.Map <List <ExperienceDto> >(list));
}
public bool UpdateExperience(ExperienceDto experience)
{
var record = _context.Experiences.FirstOrDefault(x => x.Id == experience.Id);
if (record == null)
{
return(false);
}
record.Title = experience.Title;
record.Company = experience.Company;
record.Summary = experience.Summary;
record.Location = experience.Location;
record.StartDate = experience.StartDate;
record.EndDate = experience.EndDate;
record.IsCurrent = experience.IsCurrent;
_context.Experiences.AddOrUpdate(record);
return(_context.SaveChanges() == 1);
}
public string CreateExperience(ExperienceDto experienceDto)
{
string returnMessage;
var experience = experienceDto.ToEntity();
if (experience.Id > 0)
{
_experienceDao.Update(experience);
returnMessage = "Work updated";
}
else
{
_experienceDao.Create(experience);
returnMessage = "Work created";
}
_experienceDao.Commit();
return(returnMessage);
}
public async Task <IActionResult> OnPostEditExperienceAsync()
{
ExperienceDto model = new ExperienceDto();
using (var reader = new StreamReader(Request.Body))
{
try
{
var body = await reader.ReadToEndAsync();
model = JsonConvert.DeserializeObject <ExperienceDto>(body);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
var dto = await profileService.UpdateExperience(model).ConfigureAwait(false);
return(new JsonResult(dto));
}
public async Task <IActionResult> PostExperience(int ownerId, [FromBody] ExperienceDto experienceDto)
{
if (experienceDto == null)
{
return(BadRequest());
}
Experience experience = _mapper.Map <ExperienceDto, Experience>(experienceDto);
experience.Owner_ID = ownerId;
bool isOk = await TryUpdateModelAsync(experience);
if (!isOk || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Experience result = _experienceRepository.Add(experience);
return(CreatedAtRoute("GetExperienceByID", new { ownerId = result.Owner_ID, id = result.ID }, _mapper.Map <Experience, ExperienceDto>(result)));
}
public async Task <ExperienceDto> UpdateExperience(ExperienceDto model)
{
if (model.Id == 0)
{
// we have new experience
return(await CreateExperience(model));
}
var entity = await dbContext.Experiences.FirstOrDefaultAsync(x => x.Id == model.Id);
if (entity == null)
{
return(null);
}
entity.Position = model.Position;
entity.Company = model.Company;
entity.Start = model.Start;
entity.End = model.End;
entity.Description = model.Description;
dbContext.Update(entity);
await dbContext.SaveChangesAsync();
return(ToExperienceDto(entity));
}
public bool InsertExperience(string userId, ExperienceDto experience)
{
try
{
//Validate user
if (_userRepository.IsAuthenticated(userId))
{
//Validate Model
ICollection <ValidationResult> results;
if (IsValidModel(experience, out results))
{
//Call Repository
if (_experienceRepository.InsertExperience(experience))
{
//Save
if (_experienceRepository.Save())
{
//Success
return(true);
}
_loggingService.Info("Failed To Save");
}
_loggingService.Info("UserRepository Failed Insert");
}
_loggingService.Info("Model Validation Failed: " + experience);
}
_loggingService.Info("UserId Authenticated Failed: " + userId);
}
catch (Exception ex)
{
//Error
_loggingService.Error("An error has occurred", ex);
}
//Fail
return(false);
}
public ActionResult <ExperienceDto> Post(ExperienceDto experience)
{
repository.CreateExperience(experience);
return(CreatedAtAction("GetExperience", experience));
}
public IActionResult Patch(ExperienceDto experience)
{
repository.UpdateExperience(experience);
return(Ok("Experience updated"));
}
public async Task UpdateExperience(ExperienceDto input)
{
await _experienceService.UpdateExperience(input);
}
