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); }