public IActionResult Put(SkillViewModel skillVM)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid Data"));
}
try
{
if (skillVM == null)
{
return(BadRequest("Data cannot null"));
}
var id = _skillService.GetById(skillVM.IdSkill);
if (id == null)
{
return(NotFound("Id not found !"));
}
else
{
var data = _skillService.UpdateSkill(skillVM);
return(Ok(data));
}
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public IResult DeleteSkill(SkillViewModel skill)
{
var result = new Result
{
Operation = Operation.Delete,
Status = Status.Success
};
try
{
var skillObj = _skillRepository.GetFirstOrDefault(x => x.SkillId == skill.SkillId);
if (skillObj != null)
{
skillObj.MapDeleteColumns((ClaimsIdentity)_principal.Identity);
_skillRepository.Update(skillObj);
_skillRepository.SaveChanges();
result.Message = SkillStatusNotification.SkillDeleted;
}
result.Body = skillObj;
}
catch (Exception e)
{
result.Message = e.Message;
result.Status = Status.Error;
}
return(result);
}
public async Task <IActionResult> EditSkill([FromRoute] int?id, [FromBody] SkillViewModel model)
{
if (id == null)
{
return(this.NotFound());
}
var serviceModel = await this.skillService.GetByIdAsync(model.Id);
if (serviceModel == null)
{
return(this.NotFound());
}
serviceModel.Name = model.Name;
serviceModel.Description = model.Description;
if (!this.ModelState.IsValid)
{
return(NotFound());
}
var result = await this.skillService.UpdateAsync(serviceModel);
if (!result)
{
return(NotFound());
}
return(Json(new { success = true }));
}
public IResult CreateSkill(SkillViewModel skill)
{
var result = new Result
{
Operation = Operation.Create,
Status = Status.Success
};
try
{
var duplicateSkill = _skillRepository.GetFirstOrDefault(x => x.Name == skill.Name);
if (duplicateSkill != null)
{
result.Status = Status.Fail;
result.Message = SkillStatusNotification.DuplicateSkill;
result.Body = null;
}
else
{
var skillModel = new Skills();
skillModel.MapFromViewModel(skill, (ClaimsIdentity)_principal.Identity);
_skillRepository.Create(skillModel);
_skillRepository.SaveChanges();
result.Body = skillModel;
}
}
catch (Exception e)
{
result.Message = e.Message;
result.Status = Status.Error;
}
return(result);
}
public IActionResult Update(int id, [FromBody] SkillViewModel skillVM)
{
try
{
var skill = _context.Skills.FirstOrDefault(s => s.SkillId == id);
if (skill == null)
{
return(NotFound("Skill ID with " + id + " is not found"));
}
var is_skill_exist = _context.Skills.Any(s => s.SkillName == skillVM.SkillName);
if (is_skill_exist)
{
return(StatusCode(409));
}
skillVM.SkillId = id;
_map.Map(skillVM, skill);
_context.SaveChanges();
return(new NoContentResult());
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
// GET: Skills
public async Task <IActionResult> Index(int?id)
{
var SkillViewModel = new SkillViewModel
{
Skills = _context.Skills
.Include(s => s.ApplicationUser),
UserSkills = _context.UserSkills
};
if (id != null)
{
SkillViewModel = new SkillViewModel
{
Skills = _context.Skills
.Include(s => s.ApplicationUser).Where(a => a.SkillCategoryType == SkillCategoryType.DataEntry),
UserSkills = _context.UserSkills
};
}
//var aRIDDbContext = _context.Skills
// .Include(s => s.ApplicationUser)
// .Include(s => s.Speciality);
return(View(SkillViewModel));
}
//GET - UpSkill
public IActionResult UpSkill(int?id)
{
SkillViewModel skillViewModel = new SkillViewModel()
{
Skill = new Skill(),
DogSelectList = _db.Dogs.Select(i => new SelectListItem
{
Text = i.DogName,
Value = i.Id.ToString()
})
};
if (id == null)
{
//for create new skill
return(View(skillViewModel));
}
else
{
skillViewModel.Skill = _db.Skills.Find(id);
if (skillViewModel.Skill == null)
{
return(NotFound());
}
return(View(skillViewModel));
}
}
public ActionResult Create(SkillViewModel skillViewModel)
{
try
{
//Leading and trailing empty spaces are trimmed
skillViewModel.SkillName = skillViewModel.SkillName.Trim();
skillViewModel.SkillDescription = skillViewModel.SkillDescription.Trim();
var skillCreateResult = _skillService.Create(skillViewModel.ToDTO());
//-1 is returned if new Skill has already existing Skill Name
if (skillCreateResult == -1)
{
ModelState.AddModelError("SkillName", "Skill Name Already Exists");
return(View(skillViewModel));
}
else if (skillCreateResult == 0)
{
ViewBag.Message = "Db Creation Error! Please Restart Application";
}
//Notification Message is stored in tempdata
TempData["message"] = "Successfully Added Skill";
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public void MapPrimaryandSecondarySkills(OpeningViewModel openingViewModel, Openings opening)
{
var primarySkillList = opening.OpeningSkills.Where(x => x.SkillType == OpeningSkillType.Primary && (x.IsActive && !x.IsDeleted)).Select(x => x.Skill).ToList();
var secondarySkillList = opening.OpeningSkills.Where(x => x.SkillType == OpeningSkillType.Secondary && (x.IsActive && !x.IsDeleted)).Select(x => x.Skill).ToList();
openingViewModel.PrimarySkillTypes = new List <SkillViewModel>();
openingViewModel.SecondarySkillTypes = new List <SkillViewModel>();
openingViewModel.PrimarySkills = string.Join(",", primarySkillList.Select(x => x.Name).ToList());
openingViewModel.SecondarySkills = string.Join(",", secondarySkillList.Select(x => x.Name).ToList());
if (primarySkillList.Any())
{
foreach (var skill in primarySkillList)
{
var skillViewModel = new SkillViewModel();
skillViewModel.MapFromModel(skill);
skillViewModel.OpeningSkillType = OpeningSkillType.Primary;
openingViewModel.PrimarySkillTypes.Add(skillViewModel);
}
}
if (secondarySkillList.Any())
{
foreach (var skill in secondarySkillList)
{
var skillViewModel = new SkillViewModel();
skillViewModel.MapFromModel(skill);
skillViewModel.OpeningSkillType = OpeningSkillType.Secondary;
openingViewModel.SecondarySkillTypes.Add(skillViewModel);
}
}
}
public ActionResult Edit(SkillViewModel skillView, FormCollection collection, int page)
{
try
{
//Pass current page to edit view
ViewBag.CurrentPage = page;
skillView.SkillName = skillView.SkillName.Trim();
skillView.SkillDescription = skillView.SkillDescription.Trim();
var skillUpdateResult = _skillService.Update(skillView.ToDTO());
//-1 is returned if the updated Skill Name already exists
if (skillUpdateResult == -1)
{
ModelState.AddModelError("SkillName", "Skill Name already exists");
return(View(skillView));
}
//Notification Message is stored in tempdata
TempData["message"] = "Modified skill record";
return(RedirectToAction("Index", new { page = page }));
}
catch
{
ModelState.AddModelError("SkillName", "Skill Name already exists");
return(View(skillView));
}
}
public void SaveSkills(SkillViewModel datas)
{
datas.EmployeeId = AuthenticationLogic.CurrentUserId;
var map = _mapperSkill.Map(datas);
_skill.Insert(map);
}
public void Setup()
{
_logger = A.Fake <ILogger>();
_model = A.Fake <ISkillModel>();
_skillViewModel = new SkillViewModel(_logger, _model, ViewModelCreation.GetRealAsyncCommandAdaptorFactory(), new UiThreadInvoker(_logger));
}
private static (IEnumerable <SkillViewModel> selectedSkills, SkillViewModel weakenSkill, SkillViewModel inanimateSkill) GetPsychopathSkills(Player bot)
{
var allMySkills = SkillProcedures.GetSkillViewModelsOwnedByPlayer(bot.Id).Where(s =>
s.StaticSkill.ExclusiveToFormSourceId == null && s.StaticSkill.ExclusiveToItemSourceId == null);
var selectedSkills = new List <SkillViewModel>();
SkillViewModel weakenSkill = null;
var inanimateSkill = allMySkills.FirstOrDefault(s => s.MobilityType == PvPStatics.MobilityInanimate || s.MobilityType == PvPStatics.MobilityPet);
if (inanimateSkill != null)
{
selectedSkills.Add(inanimateSkill);
}
if (bot.FirstName.Contains("Evil ") || bot.FirstName.Contains("Ruthless ") || bot.FirstName.Contains("Eternal "))
{
weakenSkill = allMySkills.FirstOrDefault(s => s.StaticSkill.Id == PvPStatics.Spell_WeakenId);
if (weakenSkill != null)
{
selectedSkills.Add(weakenSkill);
}
}
if (bot.FirstName.Contains("Eternal "))
{
var animateSkill = allMySkills.FirstOrDefault(s => s.MobilityType == PvPStatics.MobilityFull);
if (animateSkill != null)
{
selectedSkills.Add(animateSkill);
}
}
return(selectedSkills, weakenSkill, inanimateSkill);
}
public IActionResult Create([FromBody] SkillViewModel skillVM)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var is_skill_exist = _context.Skills.Any(s => s.SkillName == skillVM.SkillName);
if (is_skill_exist)
{
return(StatusCode(409));
}
_context.Add(_map.Map <Skill>(skillVM));
_context.SaveChanges();
return(NoContent());
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public IActionResult Get(int id)
{
var skillRepo = _skillRepository.GetById(id);
if (skillRepo == null)
{
return(NotFound());
}
//query the contacts for this skill to display in the view
var queryContacts = (from contacts in _contactRepository.GetAll()
join contactskills in _contactskillRepository.GetAll()
on contacts.Id equals contactskills.IdContact
where contactskills.IdSkill == skillRepo.Id
select String.Concat(contacts.FirstName, " ", contacts.LastName)).ToList();
var skillDisplay = new SkillViewModel
{
Id = skillRepo.Id,
SkillName = skillRepo.SkillName,
SkillLevel = skillRepo.SkillLevel,
FullNames = queryContacts
};
return(Ok(skillDisplay));
}
public SkillViewModel AddSkill(SkillViewModel skillVM)
{
try
{
var DuplicateSkill = _context.Skills.Where(x => x.SkillName == skillVM.SkillName).FirstOrDefault();
if (DuplicateSkill != null)
{
throw new ArgumentException("Duplicate Skill");
}
else
{
var data = _context.Add(new Skill()
{
IdSkill = skillVM.IdSkill,
SkillName = skillVM.SkillName,
SkillValue = skillVM.SkillValue
});
_context.SaveChanges();
return(skillVM);
}
}
catch (Exception ex)
{
throw ex;
}
}
public SkillViewModel Post([FromBody] SkillViewModel value, int contactId)
{
var result = MapToDomain(value);
var newSkill = _postSkillBLL.postSkillBLL(contactId, result);
return(MapFromDomain(newSkill));
}
private static SkillDomainModel MapToDomain(SkillViewModel source)
{
return(new SkillDomainModel
{
SkillId = source.skillId,
Description = source.description
});
}
public ActionResult GetSkills([DataSourceRequest] DataSourceRequest dsRequest, int userId)
{
var model = db.UserProfiles.Find(userId);
var skills = model.Skills.Select(e => SkillViewModel.CreateViewModel(e)).AsQueryable();
var viewModel = skills.ToDataSourceResult(dsRequest);
return(Json(viewModel));
}
public ActionResult CreateSkill(string returnUrl)
{
SkillViewModel skillViewModel = new SkillViewModel()
{
ReturnUrl = string.IsNullOrWhiteSpace(returnUrl) ? Url.Action("Skills") : returnUrl
};
return(View(skillViewModel));
}
public ActionResult SkillsUpdate([DataSourceRequest] DataSourceRequest request, SkillViewModel skill)
{
if (this.ModelState.IsValid)
{
this.skillService.UpdateName(skill.Id, skill.Name);
}
return this.Json(new[] { skill }.ToDataSourceResult(request, this.ModelState));
}
public JsonResult AddSkill(int adminId, SkillViewModel skillModel)
{
var admin = context.Administrators.Include(a => a.Skills).Where(a => a.Id == adminId).First();
var skillDb = context.Skills.Where(s => s.Name.ToLower() == skillModel.Name.ToLower()).FirstOrDefault();
bool result = false;
if (!ModelState.IsValid)
{
return(Json(new { success = false, message = "Invalid skill name" }));
}
Skill skill = new Skill();
skill.Name = skillModel.Name;
skill.Type = skillModel.Type;
if (skillDb == null)
{
context.Skills.Add(skill);
admin.Skills.Add(skill);
result = context.SaveChanges() > 0;
if (result)
{
return(Json(new { success = true }));
}
else
{
return(Json(new { success = false, message = "OPPS! Something went wrong." }));
}
}
else
{
var skillExist = admin.Skills.Where(s => s.Name.ToLower() == skillDb.Name.ToLower()).FirstOrDefault();
if (skillExist == null)
{
admin.Skills.Add(skill);
result = context.SaveChanges() > 0;
if (result)
{
return(Json(new { success = true }));
}
else
{
return(Json(new { success = false, message = "OPPS! Something went wrong." }));
}
}
return(Json(new { success = false, message = "Skill added before." }));
}
}
public void Delete(SkillViewModel model)
{
var item = _repository.FindById(model.Id);
if (item != null)
{
_repository.Delete(item);
}
}
public static SkillViewModel CreateSkill()
{
SkillViewModel skill = new SkillViewModel()
{
Name = GetDataHelper.GetNameFromUser(),
};
return(skill);
}
/// <summary>
/// Convert SkillViewModel to SkillDTO
/// </summary>
/// <param name="skillVM"></param>
/// <returns></returns>
public static SkillDTO ToDTO(this SkillViewModel skillVM)
{
return(new SkillDTO
{
SkillId = skillVM.skillId,
SkillName = skillVM.SkillName,
SkillDescription = skillVM.SkillDescription
});
}
public SkillViewModel UdpateSkill(int id, SkillViewModel skill)
{
var skillToUpdate = _skillRepository.GetById(id);
SkillMapper.MapModelToEntity(skill, skillToUpdate);
skillToUpdate.ModifiedBy = "TEST";
var updatedSkill = _skillRepository.Update(skillToUpdate);
return(SkillMapper.MapEntityToModel(updatedSkill));
}
public static SkillViewModel MapDbModelToViewModel(Database.Skill dbModel)
{
var viewModel = new SkillViewModel();
viewModel.Id = dbModel.Id;
viewModel.SkillName = dbModel.SkillName;
viewModel.SkillImage = dbModel.SkillImage;
return(viewModel);
}
public void CreateSkill()
{
SkillViewModel skill = SkillVMInstanceCreator.CreateSkill();
// mapping
var skillMap = Mapping.CreateMapFromVMToDomain <SkillViewModel, Skill>(skill);
// create skill
this.skillService.CreateSkill(skillMap);
}
public SkillViewModel AddSkill(SkillViewModel skill)
{
var skillToAdd = SkillMapper.MapModelToEntity(skill);
skillToAdd.CreatedBy = "TEST";
skillToAdd.SeedData = false;
var addedSkill = _skillRepository.Add(skillToAdd);
return(SkillMapper.MapEntityToModel(addedSkill));
}
public async Task <ActionResult> CreateSkill(SkillViewModel model)
{
if (ModelState.IsValid)
{
var skillDTO = _mapper.Map <SkillViewModel, SkillDTO>(model);
skillDTO.Id = new SkillDTO().Id;
await _skillService.Create(skillDTO);
}
return(RedirectToAction("Skills")); // todo returnUrl
}
public ISkillViewModel Create(UiSkill skill)
{
var skillViewModel = new SkillViewModel(_logger, _skillModelFactory.Create(), _asyncCommandAdaptorFactory, _uiThreadInvoker)
{
Skill = skill
};
skillViewModel.Init();
return(skillViewModel);
}
public void EditShouldRedirectCorrectly()
{
SkillViewModel skill = new SkillViewModel
{
Id = 42,
Name = "C#"
};
this.controller.WithCallTo(x => x.Edit(skill))
.ShouldRedirectTo(x => x.Index);
}
public ActionResult SkillsCreate([DataSourceRequest] DataSourceRequest request, SkillViewModel skill)
{
if (this.ModelState.IsValid)
{
var entity = new Skill { Name = skill.Name };
this.skillService.Add(entity);
skill.Id = entity.Id;
}
return this.Json(new[] { skill }.ToDataSourceResult(request, this.ModelState));
}
public ActionResult Delete(int id, SkillViewModel viewModel)
{
try
{
_skillService.Delete(id);
return RedirectToAction("Index");
}
catch
{
return View(viewModel);
}
}
public ActionResult AddSkill(SkillViewModel model)
{
if (!this.ModelState.IsValid)
{
return this.View(model);
}
this.developers.AddSkill(this.GetCurrentUser().Id, model.Name);
this.SetTempDataSuccessMessage("The skill is added to your developer profile!");
return this.RedirectToAction("Index");
}
public ActionResult Add(SkillViewModel model)
{
if (!this.ModelState.IsValid)
{
this.SetTempDataErrorMessage("The name of the skill is required.");
return this.RedirectToAction("Index");
}
this.skills.Add(model.Name);
this.SetTempDataSuccessMessage("The skill is added!");
return this.RedirectToAction("Index");
}
public ActionResult Edit(SkillViewModel model)
{
if (!this.ModelState.IsValid)
{
this.SetTempDataErrorMessage("Invalid skill name!");
return this.View(model);
}
this.skills.Edit(model.Id, model.Name);
this.SetTempDataSuccessMessage("The skill was edited!");
return this.RedirectToAction("Index");
}
public ActionResult Create(SkillViewModel viewModel)
{
try
{
if (!ModelState.IsValid)
return View(viewModel);
var skill = Mapper.Map<Skill>(viewModel);
_skillService.Add(skill);
return RedirectToAction("Index");
}
catch
{
return View(viewModel);
}
}
private void Load(string dataDirectory)
{
Introduction = new IntroductionViewModel(new GenericDataAccess<string>(dataDirectory, "Introduction"));
Identity = new IdentityViewModel(new GenericDataAccess<Identity>(dataDirectory, typeof(Identity).Name));
Education = new EducationViewModel(new GenericDataAccess<IEnumerable<Education>>(dataDirectory, typeof(Education).Name));
WorkExperience = new WorkExperienceViewModel(new GenericDataAccess<IEnumerable<WorkExperience>>(dataDirectory, typeof(WorkExperience).Name));
Skill = new SkillViewModel(new GenericDataAccess<IEnumerable<Skill>>(dataDirectory, typeof(Skill).Name));
}
