public ActionResult Create(UserExperience userExperience)
{
userExperience.CreatedOn = System.DateTime.Now;
userExperience.IsActive = true;
if (ModelState.IsValid)
{
db.UserExperiences.Add(userExperience);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Company_id = new SelectList(db.Companies, "id", "Companyname", userExperience.Company_id);
ViewBag.UserId = new SelectList(db.UserDetails, "ID", "UserName", userExperience.UserId);
return(View(userExperience));
}
// GET: UserExperiences/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UserExperience userExperience = db.UserExperiences.Find(id);
if (userExperience == null)
{
return(HttpNotFound());
}
ViewBag.Company_id = new SelectList(db.Companies, "id", "Companyname", userExperience.Company_id);
ViewBag.UserId = new SelectList(db.UserDetails, "ID", "UserName", userExperience.UserId);
return(View(userExperience));
}
public void TestGetExperienceFromLevel()
{
var experience = new UserExperience
{
Level = 16,
TotalXP = 229558
};
var res = DatabaseUtilities
.GetLevelFromTotalXP(
experience.TotalXP,
DiscordUtilities.LevelModifier
);
Assert.Equal(experience.Level, res);
}
public static UserExperienceModel ToUserExpModel(this UserExperience userExp)
{
var model = new UserExperienceModel();
if (userExp != null)
{
model.Id = userExp.Id;
model.JobTitle = userExp.JobTitle;
model.Description = userExp.Description;
model.CompanySite = userExp.CompanySite;
model.Time = userExp.Time;
model.MentorId = userExp.MentorId;
}
return(model);
}
// Add 'Experience(s)' Field of the 'current user'
public async Task AddTalentExperienceAsync(string userId, UserExperience userExperiences)
{
var user = (await GetTalentByIDAsync(userId));
UserExperience userExperience = new UserExperience();
userExperience.Company = userExperiences.Company;
userExperience.Position = userExperiences.Position;
userExperience.Responsibilities = userExperiences.Responsibilities;
userExperience.Start = userExperiences.Start;
userExperience.End = userExperiences.End;
user.Experience.Append(userExperience);
await _talentRepository.Update(user);
}
public IActionResult Experience(UserExperienceVM model)
{
var entity = new UserExperience()
{
UserId = model.UserId,
CompanyName = model.CompanyName,
StartDate = model.StartDate,
EndDate = model.EndDate,
JobDescription = model.JobDescription,
JobPosition = model.JobPosition,
WorkType = model.WorkType
};
_userExperienceService.Add(entity);
return(Ok());
}
//User Experience
public IActionResult AddEditUserExperience(int Id)
{
ViewBag.CountryList = new SelectList(GetCountryList(), "CountryId", "CountryName");
ExperienceVM vm = new ExperienceVM();
if (Id > 0)
{
UserExperience exp = _context.UserExperience.SingleOrDefault(x => x.UserExperienceId == Id);
vm.Title = exp.Title;
vm.CompanyName = exp.CompanyName;
vm.CityId = exp.CityID;
vm.CurrentWorkCheck = exp.CurrentWorkCheck;
vm.Description = exp.Description;
vm.StartDate = exp.StartDate;
vm.EndDate = exp.EndDate;
vm.UserExperienceId = Id;
}
return PartialView(vm);
}
public async Task <UserExperience> CreateAsync(UserExperience userExperience)
{
using (var connection = this.connectionFactory.GetEddsPerformanceConnection())
{
var readResult = await connection.QueryFirstOrDefaultAsync <UserExperience>(
Resources.UserExperienceCache_ReadByHourAndServer,
new { hourId = userExperience.HourId, serverId = userExperience.ServerId });
if (readResult == null)
{
return(await connection.QueryFirstOrDefaultAsync <UserExperience>(Resources.UserExperienceCache_Create, userExperience));
}
else
{
return(readResult);
}
}
}
public async Task CreateAsync()
{
// Arrange
var userExperience = new UserExperience
{
ActiveUsers = 123,
ArrivalRate = 0.1337m,
Concurrency = 0.1337m,
HasPoisonWaits = false,
HourId = 37715,
ServerId = 51773
};
// Act
var result = await this.userExperienceCacheRepository.CreateAsync(userExperience);
// Assert
}
public bool Modify(int id, UserExperience newUs)
{
try
{
var modifyUs = db.UserExperiences.Find(id);
modifyUs.PositionID = newUs.PositionID;
modifyUs.EnterpriseName = newUs.EnterpriseName;
modifyUs.StartTime = newUs.StartTime;
modifyUs.EndTime = newUs.EndTime;
modifyUs.Description = newUs.Description;
db.SaveChanges();
return(true);
}
catch (Exception e)
{
return(false);
}
}
public async Task <Unit> Handle(Command request,
CancellationToken cancellationToken)
{
var experience = new Experience
{
Id = request.Id,
Title = request.Title,
City = request.City,
Category = request.Category,
Date = request.Date,
DateStarted = request.DateStarted,
DateEnded = request.DateEnded,
Main = request.Main ?? "",
Main2 = request.Main2 ?? "",
Link1 = request.Link1 ?? "",
Link2 = request.Link2 ?? "",
Link1Name = request.Link1Name ?? "",
Link2Name = request.Link2Name ?? "",
Image = request.Image ?? ""
// edit not sure how to make optional here
};
_context.Experiences.Add(experience);
var user = await _context.Users.SingleOrDefaultAsync(x =>
x.UserName == _userAccessor.GetCurrentUsername());
var publisher = new UserExperience
{
AppUser = user,
Experience = experience,
IsHost = true,
DateJoined = DateTime.Now
};
_context.UserExperiences.Add(publisher);
var success = await _context.SaveChangesAsync() > 0;
if (success)
{
return(Unit.Value);
}
throw new Exception("Problem saving changes");
}
public async Task <IActionResult> UpdateExperience([FromBody] UserExperience updatedExp, String userId = "")
{
string goodNews = "Updated Successfully";
try
{
string id = String.IsNullOrWhiteSpace(userId) ? _userAppContext.CurrentUserId : userId;
if (await _profileService.UpdateExperience(id, updatedExp))
{
return(Json(new { Success = true, message = goodNews }));
}
return(Json(new { Success = false }));
}
catch (Exception e)
{
return(Json(new { Success = false, message = e.Message }));
}
}
public async Task <bool> DeleteExperienceAsync(ExperienceViewModel experience)
{
//Your code here;
// TODO: Delete experience in service
try
{
UserExperience deletedUserExperience = ExperienceFromViewModel(experience);
deletedUserExperience.IsDeleted = true;
await _userExperienceRepository.Update(deletedUserExperience);
return(true);
}
catch (Exception e)
{
return(false);
throw e;
}
}
public async Task <IEnumerable <TalentSnapshotViewModel> > GetTalentSnapshotList(string employerOrJobId, bool forJob, int position, int increment)
{
//Your code here;
IEnumerable <User> users = (await _userRepository.Get(x => !x.IsDeleted)).Skip(position).Take(increment);
List <TalentSnapshotViewModel> result = new List <TalentSnapshotViewModel>();
foreach (var user in users)
{
String name = String.Format("{0} {1}", user.FirstName, user.LastName);
UserExperience latestExperience = user.Experience.OrderByDescending(x => x.End).FirstOrDefault();
String employment, level;
if (latestExperience != null)
{
employment = latestExperience.Company;
level = latestExperience.Position;
}
else
{
employment = "Unknown";
level = "Unknown";
}
List <string> skills = user.Skills.Select(x => x.Skill).ToList();
result.Add(new TalentSnapshotViewModel {
Id = user.Id,
Name = name,
PhotoId = user.ProfilePhotoUrl,
VideoUrl = user.VideoName,
CVUrl = user.CvName,
Summary = user.Summary,
CurrentEmployment = employment,
Visa = user.VisaStatus,
Level = level,
Skills = skills,
LinkedInUrl = user.LinkedAccounts.LinkedIn,
GithubUrl = user.LinkedAccounts.Github
});
}
return(result);
}
public async Task <bool> AddNewExperience(AddExperienceViewModel experience)
{
try
{
var exp = new UserExperience
{
Id = ObjectId.GenerateNewId().ToString(),
IsDeleted = false
};
UpdateExperienceFromView(experience, exp);
await _userExperienceRepository.Add(exp);
return(true);
}
catch (MongoException e)
{
return(false);
}
}
public async Task <bool> AddUserExperience(string userId, UserExperience userExperience)
{
try
{
if (userId != null && userExperience != null)
{
User profile = await _userRepository.GetByIdAsync(userId);
profile.Experience.Add(userExperience);
await _userRepository.Update(profile);
return(true);
}
return(false);
}
catch (MongoException)
{
return(false);
}
}
public async Task <Unit> Handle(Command request,
CancellationToken cancellationToken)
{
// handler logic
var experience = await _context.Experiences.FindAsync(request.Id);
if (experience == null)
{
throw new RestException(HttpStatusCode.NotFound,
new { experience = "Could not find experience" });
}
var user = await _context.Users.SingleOrDefaultAsync(x =>
x.UserName == _userAccessor.GetCurrentUsername());
var liked = await _context.UserExperiences
.SingleOrDefaultAsync(x => x.ExperienceId == experience.Id &&
x.AppUserId == user.Id);
if (liked != null)
{
throw new RestException(HttpStatusCode.BadRequest, new { Liked = "Already liked this Experience" });
}
liked = new UserExperience
{
Experience = experience,
AppUser = user,
IsHost = false,
DateJoined = DateTime.Now
};
_context.UserExperiences.Add(liked);
var success = await _context.SaveChangesAsync() > 0;
if (success)
{
return(Unit.Value);
}
throw new Exception("Problem saving changes");
}
public void DetermineEligibleArrivalRateSample(int totalQueriesForHour, bool expectedResult)
{
// Arrange
var arrivalRate = this.userExperienceService.CalculateFinalArrivalRate(totalQueriesForHour);
var userExperienceTest = new UserExperience
{
ActiveUsers = 2,
ArrivalRate = arrivalRate,
Concurrency = 1000,
HasPoisonWaits = false
};
var userExperienceData = new List <UserExperience> {
userExperienceTest
};
// Act
var result = this.userExperienceSampleService.DetermineEligibleArrivalRateSample(userExperienceData);
// Assert
Assert.That(result.Any(), Is.EqualTo(expectedResult));
}
public ActionResult AddExperience([FromBody] ExperienceViewModel experience)
{
if (ModelState.IsValid)
{
String id = " ";
String talentId = String.IsNullOrWhiteSpace(id) ? _userAppContext.CurrentUserId : id;
var addExperience = new UserExperience
{
Id = ObjectId.GenerateNewId().ToString(),
Company = experience.Company,
Position = experience.Position,
Responsibilities = experience.Responsibilities,
Start = experience.Start,
End = experience.End,
};
var user = _userRepository.GetByIdAsync(talentId).Result;
user.Experience.Add(addExperience);
_userRepository.Update(user);
return(Json(new { Success = true }));
}
return(Json(new { Success = false }));
}
public JsonResult Modify(int id, int position, string nameEnterprise, string timeStart, string timeEnd, string description)
{
var newModify = new UserExperience();
newModify.PositionID = position;
newModify.EnterpriseName = nameEnterprise;
newModify.StartTime = timeStart;
if (timeEnd != null && timeEnd != "")
{
newModify.EndTime = timeEnd;
}
if (description != null && description != "")
{
newModify.Description = description;
}
var check = new UserExperienceDao().Modify(id, newModify);
return(Json(new
{
status = check
}));
}
public async Task CalculateSample_OneHour_NoCache()
{
var serverId = 3;
var hourId = 2;
var hour = new Hour();
var pastWeekHour = new Hour();
var pastWeekHours = new List <Hour> {
pastWeekHour
};
// read hours
this.hourRespositoryMock.Setup(m => m.ReadAsync(hourId)).ReturnsAsync(hour);
this.hourRespositoryMock.Setup(m => m.ReadPastWeekHoursAsync(hour)).ReturnsAsync(pastWeekHours);
// read empty cache
var userExperienceCacheModels = new List <UserExperience>();
this.userExperienceCacheRepositoryMock
.Setup(m => m.ReadAsync(serverId, pastWeekHour.HourTimeStamp, pastWeekHour.HourTimeStamp))
.ReturnsAsync(userExperienceCacheModels);
// Build ux models
var userExperienceModel = new UserExperience();
this.userExperienceServiceMock.Setup(m => m.BuildUserExperienceModel(serverId, pastWeekHour))
.ReturnsAsync(userExperienceModel);
this.userExperienceCacheRepositoryMock.Setup(m => m.CreateAsync(userExperienceModel))
.ReturnsAsync(userExperienceModel);
// Determine eligibility - None
var result = await this.userExperienceSampleService.CalculateSample(serverId, hourId);
Assert.That(result.HourId, Is.EqualTo(hourId));
Assert.That(result.ServerId, Is.EqualTo(serverId));
Assert.That(result.ArrivalRateHours, Is.Empty);
Assert.That(result.ConcurrencyHours, Is.Empty);
}
private List <UserExperience> UpdateExperienceList(User user, List <ExperienceViewModel> experience)
{
var newExperienceList = new List <UserExperience>();
if (experience is null)
{
return(newExperienceList);
}
foreach (var exp in experience)
{
var userExperience = user.Experience.SingleOrDefault(x => x.Id == exp.Id);
if (userExperience == null)
{
userExperience = new UserExperience
{
Id = ObjectId.GenerateNewId().ToString(),
Company = exp.Company,
Responsibilities = exp.Responsibilities,
Position = exp.Position,
Start = exp.Start,
End = exp.End
};
}
else
{
userExperience.Company = exp.Company;
userExperience.Responsibilities = exp.Responsibilities;
userExperience.Position = exp.Position;
userExperience.Start = exp.Start;
userExperience.End = exp.End;
}
newExperienceList.Add(userExperience);
}
return(newExperienceList);
}
public ActionResult addUserEXP([FromBody] ExperienceViewModel model)
{
//Your code here;
var objectId = ObjectId.GenerateNewId().ToString();
var userId = _userAppContext.CurrentUserId;
var userEXP = new UserExperience()
{
Id = objectId,
UserId = userId,
Company = model.Company,
Position = model.Position,
Responsibilities = model.Responsibilities,
Start = model.Start,
End = model.End
};
_userExperienceRepository.Add(userEXP);
return(Json(new { Success = "ture", message = "UserEXP added" }));
}
public async Task CalculateSample_OneHour_WithCache()
{
var serverId = 3;
var hourId = 2;
var hour = new Hour {
Id = hourId
};
var pastWeekHourId = 1;
var pastWeekHour = new Hour {
Id = pastWeekHourId
};
var pastWeekHours = new List <Hour> {
pastWeekHour
};
this.hourRespositoryMock.Setup(m => m.ReadAsync(hourId)).ReturnsAsync(hour);
this.hourRespositoryMock.Setup(m => m.ReadPastWeekHoursAsync(hour)).ReturnsAsync(pastWeekHours);
// read cache
var userExperienceModel = new UserExperience()
{
HourId = pastWeekHourId
};
var userExperienceModels = new List <UserExperience> {
userExperienceModel
};
this.userExperienceCacheRepositoryMock
.Setup(m => m.ReadAsync(serverId, pastWeekHour.HourTimeStamp, pastWeekHour.HourTimeStamp))
.ReturnsAsync(userExperienceModels);
var result = await this.userExperienceSampleService.CalculateSample(serverId, hourId);
Assert.That(result.HourId, Is.EqualTo(hourId));
Assert.That(result.ServerId, Is.EqualTo(serverId));
Assert.That(result.ArrivalRateHours, Is.Empty);
Assert.That(result.ConcurrencyHours, Is.Empty);
}
public async Task <bool> DeleteExperience(string userId, string experienceId)
{
try
{
if (userId != null)
{
User profile = await _userRepository.GetByIdAsync(userId);
UserExperience whereToDelete = profile.Experience.SingleOrDefault(x => x.Id == experienceId);
profile.Experience.Remove(whereToDelete);
await _userRepository.Update(profile);
return(true);
}
return(false);
}
catch (MongoException)
{
return(false);
}
}
public JsonResult Insert(int position, string nameEnterprise, string timeStart, string timeEnd, string description)
{
var accID = int.Parse(User.Identity.Name);
var acc = new AccountDao().FindAccountById(accID);
var usInsert = new UserExperience();
usInsert.UserID = acc.UserId;
usInsert.PositionID = position;
usInsert.EnterpriseName = nameEnterprise;
usInsert.StartTime = timeStart;
if (timeEnd != null && timeEnd != "")
{
usInsert.EndTime = timeEnd;
}
if (description != null && description != "")
{
usInsert.Description = description;
}
return(Json(new
{
status = new UserExperienceDao().Insert(usInsert)
}));
}
public async Task <IActionResult> AddExperience([FromBody] UserExperience model)
{
if (ModelState.IsValid)
{
try
{
var id = await resumeRepository.addExperience(model);
if (id >= 0)
{
return(Ok(id));
}
else
{
return(NotFound());
}
}
catch (Exception)
{
return(BadRequest());
}
}
return(BadRequest());
}
public async Task <IActionResult> UpdatePost([FromBody] UserExperience model)
{
if (ModelState.IsValid)
{
try
{
await resumeRepository.updateExperience(model);
return(Ok());
}
catch (Exception ex)
{
if (ex.GetType().FullName ==
"Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException")
{
return(NotFound());
}
return(BadRequest());
}
}
return(BadRequest());
}
public async Task <ServiceResult> AddExpForRegisterAsync(string userId)
{
try
{
// Create new exp record
UserExperience record = EntityFactory
.CreateUserExperience(userId, Constraint.MemberExpSystem.UserRegister.ID,
Constraint.MemberExpSystem.UserRegister.NAME,
Constraint.MemberExpSystem.UserRegister.EXP);
// insert record in history get exp
await this.m_userExperienceRepository.InsertAsync(record);
// save changes for user exp
await this.m_userExperienceRepository.SaveChangesAsync();
// return successfull
return(ServiceResult.Success);
}
catch (Exception ex)
{
// return error
return(ServiceResult.AddError(ex.Message));
}
}
protected ExperienceViewModel ViewModelFromExperience(UserExperience experience)
{
if (experience == null)
{
experience = new UserExperience
{
Id = "",
Company = "",
Position = "",
Responsibilities = "",
Start = DateTime.Now,
End = DateTime.Now,
};
}
return(new ExperienceViewModel
{
Id = experience.Id,
Company = experience.Company,
Position = experience.Position,
Responsibilities = experience.Responsibilities,
Start = experience.Start,
End = experience.End
});
}
