public Language Add(CreateLanguageViewModel createLanguageViewModel)
{
Language lang = new Language(); //new language to be added
List <PersonLanguage> allPersonLang = new List <PersonLanguage>(); //placeholder list
foreach (int id in createLanguageViewModel.ListPersonID)
{
lang.LanguageName = createLanguageViewModel.LanguageName;
PersonLanguage personLang = new PersonLanguage();
personLang.LanguageID = lang.LanguageID; //createLanguageViewModel.LanguageID;
personLang.Person = _peopleService.FindBy(id);
personLang.Language = lang;
personLang.PersonID = id;
allPersonLang.Add(personLang);
lang.PL = allPersonLang;
//_personLangService.Add(id, language.LanguageID);
}
Language language = _languageRepo.Create(lang);
return(language);
}
public ActionResult AddLanguageToPerson(PersonLanguageViewModel personLanguageViewModel)
{
if (ModelState.IsValid)
{
var personID = personLanguageViewModel.Person.Id;
var languageID = personLanguageViewModel.Language.Id;
var existingItems = _context.PersonLanguage
.Where(pl => pl.PersonID == personID)
.Where(pl => pl.LanguageID == languageID).ToList();
if (existingItems.Count == 0)
{
PersonLanguage newItem = new PersonLanguage
{
Person = _context.People.Single(p => p.Id == personID),
Language = _context.Language.Single(l => l.Id == languageID)
};
_context.PersonLanguage.Add(newItem);
_context.SaveChanges();
}
return(RedirectToAction(nameof(Index)));
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult DeleteConfirmed(int id)
{
PersonLanguage personLanguage = db.PersonLanguages.Find(id);
db.PersonLanguages.Remove(personLanguage);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public PersonLanguage Create(PersonLanguage personLanguage)
{
PersonLanguage addPersonLanguage = personLanguage;
_peopleDbContext.Add(addPersonLanguage);
_peopleDbContext.SaveChanges();
return(addPersonLanguage);
}
public PersonLanguage Add(int personId, int langId)
{
PersonLanguage pl = new PersonLanguage();
pl.LanguageId = langId;
pl.PersonId = personId;
return(Add(pl));
}
public PersonLanguage Create(PersonLanguage personLanguage)
{
_peopleDbContext.PersonLanguage.Add(personLanguage);
if (_peopleDbContext.SaveChanges() > 0)
{
return(personLanguage);
}
return(null);
}
public bool Delete(PersonLanguage personLanguage)
{
bool delete = true;
if (delete == true)
{
_peopleDbContext.PersonLanguage.Remove(personLanguage);
_peopleDbContext.SaveChanges();
}
return(delete);
}
public PersonLanguage Add(int personID, int languageID)
{
Language l = null; // _languageService.FindBy(languageID);
Person p = null; //_peopleService.FindBy(personID);
PersonLanguage personLang = new PersonLanguage()
{
PersonID = personID, LanguageID = languageID, Person = p, Language = l
};
_personLangRepo.Create(personLang);
return(personLang);
}
public ActionResult Edit([Bind(Include = "PersonLanguageID,PersonID,LanguageID")] PersonLanguage personLanguage)
{
if (ModelState.IsValid)
{
db.Entry(personLanguage).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.LanguageID = new SelectList(db.Languages, "LanguageID", "Description", personLanguage.LanguageID);
ViewBag.PersonID = new SelectList(db.People, "PersonID", "PersonName", personLanguage.PersonID);
return(View(personLanguage));
}
private static PersonLanguage MapLanguageList(IDataReader reader, out int personId)
{
PersonLanguage bl = new PersonLanguage();
int ord = 0;
personId = reader.GetSafeInt32(ord++);
bl.Key = reader.GetSafeString(ord++);
bl.LanguageId = reader.GetSafeInt32(ord++);
bl.LanguageName = reader.GetSafeString(ord++);
bl.LanguageProficiencyId = reader.GetSafeInt32(ord++);
bl.LanguageProficiencyCode = reader.GetSafeString(ord++);
return(bl);
}
public IActionResult PersonLanguageAdd(int personId, int languageId)
{
Person person = _peopleService.FindBy(personId);
Language l = _languageService.FindbyId(languageId);
if (person != null || l != null)
{
PersonLanguage personLanguage = _personLanguageService.Add(personId, languageId);
return(RedirectToAction("LanguageManagement", new { id = personId }));
}
return(RedirectToAction("Index"));
}
// GET: PersonLanguages/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PersonLanguage personLanguage = db.PersonLanguages.Find(id);
if (personLanguage == null)
{
return(HttpNotFound());
}
return(View(personLanguage));
}
public IActionResult Post([FromBody] PersonLanguage value)
{
try
{
using (var db = My.ConnectionFactory())
{
int result = db.Execute($@"IF EXISTS({My.Table_PersonLanguage.SelectSingle}) {My.Table_PersonLanguage.Update} ELSE {My.Table_PersonLanguage.Insert}", value);
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
// GET: PersonLanguages/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PersonLanguage personLanguage = db.PersonLanguages.Find(id);
if (personLanguage == null)
{
return(HttpNotFound());
}
ViewBag.LanguageID = new SelectList(db.Languages, "LanguageID", "Description", personLanguage.LanguageID);
ViewBag.PersonID = new SelectList(db.People, "PersonID", "PersonName", personLanguage.PersonID);
return(View(personLanguage));
}
public bool Delete(int personId, int langId)
{
PersonLanguage pl = Read(personId, langId);
if (pl == null)
{
return(false);
}
_peopleDbContext.Remove(pl);
int result = _peopleDbContext.SaveChanges();
if (result == 0)
{
return(false);
}
return(true);
}
public IActionResult AddLanguageToPerson(int personId, int languageId) // personId and languageId is needed for the binding
{
Person person = _peopleService.FindById(personId);
if (person == null)
{
return(RedirectToAction("Index"));
}
PersonLanguage personLanguage = _personLanguageRepo.Create(
new PersonLanguage()
{
PersonId = personId, LanguageId = languageId
}
);
return(RedirectToAction("ManagePersonLanguages", new { id = personId }));
}
public bool Delete(int pId, int langId)
{
PersonLanguage personLanguage = Read(pId, langId);
if (personLanguage == null)
{
return(false);
}
_context.PersonLanguages.Remove(personLanguage);
if (_context.SaveChanges() > 0)
{
return(true);
}
return(false);
}
public ActionResult AddLanguage(AddLanguageViewModel language)
{
try
{
var newLanguage = new PersonLanguage
{
PersonId = _appContext.LoginId,
LanguageLevel = language.Level,
Language = language.Name,
};
_personLanguageRepository.Add(newLanguage);
return(new JsonCamelCaseResult(new { Success = true, newLanguage.Id }, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(new JsonCamelCaseResult(new { Success = false, Message = "Error while adding new language" }, JsonRequestBehavior.AllowGet));
}
}
public bool Delete(int personId, int languageId)
{
PersonLanguage personlang = Read(personId, languageId);
if (personlang == null)
{
return(false);
}
_peopleDbContext.PersonLanguage.Remove(personlang);
if (_peopleDbContext.SaveChanges() > 0)
{
return(true);
}
return(false);
}
public IActionResult PersonLanguageRemove(int personId, int languageId)
{
PersonLanguage pl = _personLanguageService.FindbyId(personId, languageId);
if (pl == null)
{
return(RedirectToAction("Index"));
}
bool result = _personLanguageService.Remove(personId, languageId);
if (result)
{
return(RedirectToAction("LanguageManagement", new { id = personId }));
}
return(RedirectToAction("Index"));
}
public IActionResult AddLanguageToPerson(int pId, int langId)
{
Person person = _service.FindBy(pId);
if (person == null)
{
return(RedirectToAction("Index"));
}
PersonLanguage pl = _personLanguageService.Create(
new PersonLanguage()
{
PersonId = pId, LanguageId = langId
}
);
return(RedirectToAction("UpdatePersonLanguages", new { id = pId }));
}
public ActionResult Create(CreatePersonViewModel createPersonViewModel)
{
PersonLanguage personLanguage = new PersonLanguage();
//Person person = new Person();
if (ModelState.IsValid)
{
createPersonViewModel.Country = _countryService.FindBy(createPersonViewModel.Country.Id);
createPersonViewModel.City = _citysService.FindBy(createPersonViewModel.City.Id);
//createPersonViewModel.PersonLanguage = _languageService.FindBy(createPersonViewModel.PersonLanguage.;
if (createPersonViewModel.City != null && createPersonViewModel.Country != null)
{
_peopleService.Add(createPersonViewModel);
return(RedirectToAction(nameof(Index)));
}
}
return(View(createPersonViewModel));
}
public IActionResult AddLanguageToPerson(int personId, int langId)
{
Person person = _peopleService.FindbyId(personId);
if (person == null)
{
return RedirectToAction("Index");
}
PersonLanguage personLanguage = _personLanguageService.Add(// Ändra till Service
new PersonLanguage() { PersonId = personId, LanguageId = langId });
return RedirectToAction("ManagePersonLanguages", new { id = personId });
}
public async Task<string> Handle(DeletePersonLanguageCommand request, CancellationToken cancellationToken)
{
using (_context)
{
PersonLanguage toDeletePersonLanguage = new PersonLanguage();
toDeletePersonLanguage = await (from pl in _context.PersonLanguage where pl.Id == request.ID select pl).FirstOrDefaultAsync();
if (toDeletePersonLanguage != null)
{
_context.PersonLanguage.Remove(toDeletePersonLanguage);
await _context.SaveChangesAsync(cancellationToken);
}
}
return string.Empty;
}
public Person Edit(int id, CreatePersonViewModel person)
{
if (person.ShouseLanguage != null)
{
Person persons = new Person();
persons.Languages = new List <PersonLanguage>();
foreach (var language in person.ShouseLanguage)
{
Language lang = _languageService.FindBy(language);
PersonLanguage langID = new PersonLanguage()
{
LanguageID = lang.Id, Language = lang
};
persons.Languages.Add(langID);
}
// PersonLanguage pl = new PersonLanguage();
Person editPerson = new Person()
{
Id = id, Name = person.Name, City = person.City, Country = person.Country, PhoneNumber = person.PhoneNumber, Languages = persons.Languages
};
return(_peopleRepo.Update(editPerson));
throw new NotImplementedException();
}
else
{
Person editPerson = new Person()
{
Id = id, Name = person.Name, City = person.City, Country = person.Country, PhoneNumber = person.PhoneNumber
};
return(_peopleRepo.Update(editPerson));
}
}
public Person Add(CreatePersonViewModel modelData)
{
Person newPerson = new Person(); //new person to be added
newPerson.FirstName = modelData.FirstName;
newPerson.LastName = modelData.LastName;
newPerson.PhoneNumber = modelData.PhoneNumber;
newPerson.Address = modelData.Address;
List <PersonLanguage> allPersonLang = new List <PersonLanguage>(); //placeholder list
foreach (int languageID in modelData.ListLanguageID)
{
PersonLanguage personLang = new PersonLanguage();
//personLang.Language = _langService.FindBy(languageID);
personLang.LanguageID = languageID; //createLanguageViewModel.LanguageID;
//personLang.Person = newPerson;
personLang.PersonID = newPerson.PersonID;
allPersonLang.Add(personLang);
//_personLangService.Add(id, language.LanguageID);
}
newPerson.PersonLanguages = allPersonLang;
Person personAdded = pr.Create(newPerson);
/* Person personAdded = pr.Create(modelData.FirstName, modelData.LastName, modelData.PhoneNumber, modelData.Address);
* foreach (int languageID in modelData.ListLanguageID)
* {
* _personLangservice.Add(personAdded.PersonID, languageID);
* }*/
return(personAdded);
}
public PersonLanguage Add(PersonLanguage personLanguage)
{
return(_personLanguageRepo.Create(personLanguage));
}
public bool Remove(PersonLanguage personLang)
{
return(_personLangRepo.Delete(personLang));
}
public List <Person> GetAll()
{
List <Person> list = null;
DataProvider.ExecuteCmd(GetConnection, "dbo.Person_SelectAll"
, inputParamMapper : null
, map : delegate(IDataReader reader, short set)
{
switch (set)
{
case 0:
Person p = MapPerson(reader);
if (list == null)
{
list = new List <Person>();
}
list.Add(p);
break;
case 1:
int personId = 0;
MilitaryBase mb = MapMilitaryBaseList(reader, out personId);
Person person = list.Find(item => item.Id == personId);
if (person.MilitaryBases == null)
{
person.MilitaryBases = new List <MilitaryBase>();
}
person.MilitaryBases.Add(mb);
break;
case 2:
int personaId = 0;
PersonLanguage bl = MapLanguageList(reader, out
personaId);
Person persona = list.Find(item => item.Id == personaId);
if (persona != null)
{
if (persona.Languages == null)
{
persona.Languages = new List <PersonLanguage>();
}
persona.Languages.Add(bl);
}
break;
case 3:
int personalId = 0;
Skill sk = MapSkillList(reader, out personalId);
Person personal = list.Find(item => item.Id == personalId);
if (personal != null)
{
if (personal.Skills == null)
{
personal.Skills = new List <Skill>();
}
personal.Skills.Add(sk);
}
break;
default:
break;
}
}
);
return(list);
}
public Person PublicSelect(int id)
{
Person person = null;
List <MilitaryBase> mbList = null;
List <PersonLanguage> laList = null;
List <Skill> skList = null;
DataProvider.ExecuteCmd(GetConnection, "dbo.Person_SelectById",
inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@Id", id);
}
, map : delegate(IDataReader reader, short set)
{
switch (set)
{
case 0:
person = MapPerson(reader);
break;
case 1:
int personId = 0;
MilitaryBase mb = MapMilitaryBaseList(reader, out personId);
if (mbList == null)
{
mbList = new List <MilitaryBase>();
}
mbList.Add(mb);
break;
case 2:
PersonLanguage la = MapLanguageList(reader, out personId);
if (laList == null)
{
laList = new List <PersonLanguage>();
}
laList.Add(la);
break;
case 3:
Skill sk = MapSkillList(reader, out personId);
if (skList == null)
{
skList = new List <Skill>();
}
skList.Add(sk);
break;
case 4:
CompanyBase cb = MapCompany(reader, out personId);
if (person.Companies == null)
{
person.Companies = new List <CompanyBase>();
}
person.Companies.Add(cb);
break;
case 5:
SquadBase sq = MapSquad(reader, out personId);
if (person.Squads == null)
{
person.Squads = new List <SquadBase>();
}
person.Squads.Add(sq);
break;
case 6:
PersonNotificationPreference pnp = PreferenceMap(reader, out personId);
if (person.Preferences == null)
{
person.Preferences = new List <PersonNotificationPreference>();
}
person.Preferences.Add(pnp);
break;
}
}
);
person.MilitaryBases = mbList;
person.Languages = laList;
person.Skills = skList;
return(person);
}
