public ActionResult Create([Bind(Include = "JobPositionId,JobTitle,IsActive,CompanyId")] JobPosition jobPosition)
{
if (ModelState.IsValid)
{
db.Jobs.Add(jobPosition);
db.SaveChanges();
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
var companies = db.UserCompanies.Where(w => w.User.UserName == User.Identity.Name).Select(s => s.CompanyId).Distinct().ToList();
ViewBag.CompanyId = new SelectList(db.Companies.Where(w => companies.Contains((int)w.CompanyId)), "CompanyId", "Name", jobPosition.CompanyId);
return(PartialView("_Create", jobPosition));
}
public static RulePoint GetPoint(CalculationData data, JobPosition job, string name)
{
try
{
if (!data.Points.JobResults.Any(j => j.Key == job.DictionaryName))
{
return(null);
}
return(Utils.Res.JobResults[job.DictionaryName].Results.SingleOrDefault(j => j.Name == name));
}
catch (Exception ex)
{
throw exceptionConvertor(ex, name);
}
}
public static JobPositionModel MapJobPositionToJobPositionModel(this JobPosition jobPosition)
{
if (jobPosition == null)
{
return(null);
}
var jobPositionModel = new JobPositionModel
{
Id = jobPosition.JobPositionId,
Name = jobPosition.PositionName
};
return(jobPositionModel);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
JobPosition = await _context.JobPositions.FirstOrDefaultAsync(m => m.Id == id);
if (JobPosition == null)
{
return(NotFound());
}
return(Page());
}
public IActionResult AddOpenPosition([FromBody] JobPosition entity)
{
var decodedToken = authentication.DecodeTokenFromRequest(Request.Headers["Authorization"]);
string role = authentication.GetRoleFromToken(decodedToken);
int id = authentication.GetIDFromToken(decodedToken);
if (role == "Club")
{
if (_clubLogic.AddOpenPosition(entity, id))
{
return(Ok());
}
}
return(StatusCode(500, "Failed"));
}
public OperationResultVo GenerateNew(Guid currentUserId, JobPositionOrigin origin)
{
try
{
JobPosition newJobPosition = jobPositionDomainService.GenerateNewJobPosition(currentUserId, origin);
JobPositionViewModel newVm = mapper.Map <JobPositionViewModel>(newJobPosition);
return(new OperationResultVo <JobPositionViewModel>(newVm));
}
catch (Exception ex)
{
return(new OperationResultVo(ex.Message));
}
}
//TO DO:Remove or change
public static JobPosition MapJobPositionModelToJobPosition(this JobPositionModel jobPositionModel)
{
if (jobPositionModel == null)
{
return(null);
}
var jobPosition = new JobPosition
{
JobPositionId = jobPositionModel.Id,
PositionName = jobPositionModel.Name
};
return(jobPosition);
}
public void Wall_Moderator_Can_Remove_User_From_Wall()
{
// Arrange
var moderatingUserId = "moderator1";
var userToRemoveId = "user1";
var tenantId = 2;
var jobPosition = new JobPosition {
Title = "jobpos"
};
var users = new List <ApplicationUser>
{
new ApplicationUser {
Id = userToRemoveId, OrganizationId = tenantId, FirstName = "fname", LastName = "lname", PictureId = "pic", JobPosition = jobPosition
}
};
_usersDbSet.SetDbSetData(users);
var moderators = new List <WallModerator>
{
new WallModerator {
Id = 1, UserId = "moderator1", WallId = 1
}
};
var members = new List <WallMember>
{
new WallMember {
Id = 1, UserId = userToRemoveId, WallId = 1
}
};
var walls = new List <Wall>
{
new Wall {
Id = 1, OrganizationId = 2, Type = WallType.UserCreated, Moderators = moderators, Members = members
}
};
_wallsDbSet.SetDbSetData(walls);
// Act
_wallService.JoinLeaveWall(1, userToRemoveId, moderatingUserId, tenantId, false);
// Assert
_wallUsersDbSet.Received(1).Remove(Arg.Is <WallMember>(u => u.WallId == 1));
}
public async Task <int> HandleAsync(PostJobPositionCommandGetJobPositionIdQuery query, CancellationToken cancellationToken = new CancellationToken())
{
var newjobposition = new JobPosition()
{
TitleEng = query.TitleEng,
TitleFre = query.TitleFre,
Active = 1
};
await _db.JobPositions.AddAsync(newjobposition, cancellationToken);
await _db.SaveChangesAsync(cancellationToken);
return(await _db.JobPositions.Where(e => e.TitleEng == query.TitleEng || e.TitleFre == query.TitleFre)
.Select(e => e.Id)
.FirstOrDefaultAsync(cancellationToken));
}
private JobPosition createJobPosition(Period period, JobPosition parentPosition)
{
JobPosition res = null;
using (var session = PMSSession.GetSession())
using (session.BeginTransaction())
{
var sharedJp = createSharedJobPosition();
var unit = createUnitInPeriod(period);
var job = createJobInPeriod(period);
res = new JobPosition(period, sharedJp, parentPosition, job, unit);
session.Save(res);
session.Transaction.Commit();
}
return(res);
}
public JobPosition UpdateJobPosition(int id, JobPosition newJobPosition)
{
var jobPosition = this.context.JobPositions.FirstOrDefault(i => i.Id == id);
if (jobPosition == null)
{
throw new ArgumentException("Invalid job position id.", "id");
}
jobPosition.Name = newJobPosition.Name;
jobPosition.UpdatedAt = DateTime.UtcNow;
this.context.SaveChanges();
return(jobPosition);
}
/// <summary>
/// Checks if the number of clicks the player has is enough to be promoted
/// </summary>
void CheckForPromotion()
{
//Hook up prestige if the promotion has reached max
if (currentClicks >= currentJob.ClicksToPromotion)
{
if (currentJob.NextPosition == null)
{
gm.Prestige();
return;
}
else
{
currentJob = currentJob.NextPosition;
}
}
}
public async Task <Unit> Handle(CreateJobPositionCommand request, CancellationToken cancellationToken)
{
var user = _userAccessor.GetUser();
var userId = Guid.Parse(user.FindFirst(ClaimTypes.NameIdentifier).Value);
var entity = new JobPosition
{
Description = request.Description,
HourlySalary = request.HourlySalary,
Abbreviation = request.Abbreviation
};
entity.CreateEnd(Guid.NewGuid(), request.Name, userId);
if (request.Active)
{
entity.Activate();
}
else
{
entity.Deactivate();
}
if (request.DepartmentTeamId != null)
{
var jobTeam = new JobDepartmentTeam
{
DepartmentTeamId = request.DepartmentTeamId.Value,
JobPositionId = entity.Id
};
_context.JobDepartmentTeams.Add(jobTeam);
}
_context.JobPositions.Add(entity);
await _mediator.Publish(new JobPositionCreated()
{
PrimaryEntityId = entity.Id,
PrimaryEntityName = entity.Name,
UserName = user.Identity.Name
}, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public ActionResult Show(int?id)
{
if ((id == null) || (db.JobPositions.Find(id) == null))
{
return(NotFound());
}
//Raw MSSQL query
string query = "select * from positions where jobid=@id";
SqlParameter myparam = new SqlParameter("@id", id);
JobPosition myjob = db.JobPositions.Include(b => b.Hospital).Include(b => b.ResumeID).SingleOrDefault(b => b.JobID == id);
return(View(myjob));
}
private void buttonAddJobPositionAdd_Click(object sender, EventArgs e)
{
if (panelAddJobPosition.CheckFullnessOfContols())
{
JobPosition jobPosition = new JobPosition();
jobPosition.Name = textBoxAddJobPosition.Text;
context.JobPositions.Add(jobPosition);
context.SaveChanges();
textBoxAddJobPosition.Text = string.Empty;
dataGridJobPosition.AddClearRange(context.JobPositions.ToList());
comboBoxJobPosition.AddClearEntities <JobPosition>(context, "Name");
comboBoxEditJobPosition.AddClearEntities <JobPosition>(context, "Name");
}
}
public IActionResult AddJob([FromBody] JobPosition job)
{
if (job == null)
{
return(BadRequest());
}
try
{
_jobRepository.AddJob(job);
}
catch (Exception)
{
return(BadRequest());
}
return(Ok("Sve je u redu"));
}
public void JobPosition_CanBeUpdated()
{
context.JobPositions.Add(new JobPosition {
Name = "JobPosition"
});
context.SaveChanges();
var service = new JobPositionService(context);
var updateData = new JobPosition {
Name = "JobPosition2"
};
var jobPosition = service.UpdateJobPosition(1, updateData);
var jobPositionRecord = context.JobPositions.Single(i => i.Name == "JobPosition2");
Assert.AreEqual("JobPosition2", jobPosition.Name);
Assert.AreEqual("JobPosition2", jobPositionRecord.Name);
}
public void Exist_ReturnsTrue()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>().UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
using (var dbContext = new ApplicationDbContext(options))
{
JobPosition jobPosition = new JobPosition()
{
Name = "newJobPos",
};
dbContext.JobPositions.Add(jobPosition);
dbContext.SaveChanges();
OperatingLocation operatingLocation = new OperatingLocation()
{
Town = "Sofia",
Address = "test street",
ImageUrl = "kgkkkgk",
};
dbContext.OperatingLocations.Add(operatingLocation);
dbContext.SaveChanges();
Employee employee = new Employee()
{
FirstName = "Ivan",
MiddleName = "Ivanov",
LastName = "Ivanov",
PhoneNumber = "0897924218",
Email = "*****@*****.**",
Town = "Sofia",
Address = "address 1",
ImageUrl = "aasdfag",
OperatingLocationId = operatingLocation.Id,
JobPositionId = jobPosition.Id,
};
dbContext.Employees.Add(employee);
dbContext.SaveChanges();
var employeesService = new EmployeesService(dbContext);
var result = employeesService.Exists(employee.Id);
Assert.True(result);
}
}
private void SeedPositions()
{
var list = new List <JobPosition>();
for (int i = 0; i < LoopIterations; i++)
{
var position = new JobPosition
{
Name = i == 0 ? PositionName : PositionName + i,
Salary = i == 0 ? Salary : Salary + i
};
list.Add(position);
}
this.context.Positions.AddRange(list);
this.context.SaveChanges();
}
public ActionResult Insert(JobPosition newJobPosition, int userId)
{
if (newJobPosition == null)
{
return(ActionResult.NoAction);
}
var res = newJobPosition.Insert(userId);
if (res.Success)
{
// Añadir traza
res = ActivityLog.JobPosition(newJobPosition.Id, userId, newJobPosition.CompanyId, JobPositionLogActions.Create, string.Empty);
res.SetSuccess(newJobPosition.Id);
}
return(res);
}
public static RulePoint AddEmployeePoint(JobPosition job, KeyValuePair <JobIndex, Dictionary <Employee, List <Inquiry> > > index,
string name, decimal value, bool final = false)
{
var res = new RulePoint {
Name = name, Value = value, Final = final
};
if (!Utils.Res.JobResults.Any(j => j.Key == job.DictionaryName))
{
Utils.Res.JobResults.Add(job.DictionaryName, new JobPositionResult());
}
if (!Utils.Res.JobResults[job.DictionaryName].IndexResults.Any(j => j.Key == index.Key.DictionaryName))
{
Utils.Res.JobResults[job.DictionaryName].IndexResults.Add(index.Key.DictionaryName, new List <RulePoint>());
}
Utils.Res.JobResults[job.DictionaryName].IndexResults[index.Key.DictionaryName].Add(res);
return(res);
}
public ReturnResult <JobPosition> AddNewJobPosition(JobPosition JobPosition)
{
var result = new ReturnResult <JobPosition>();
DbProvider db = new DbProvider();
string outCode = String.Empty;
string outMessage = String.Empty;
string totalRecords = String.Empty;
try
{
// Set tên stored procedure
db.SetQuery("JobPosition_AddNew", CommandType.StoredProcedure)
.SetParameter("PositionName", SqlDbType.NVarChar, JobPosition.PositionName)
.SetParameter("Description", SqlDbType.NVarChar, JobPosition.Description)
.SetParameter("CreatedUser", SqlDbType.NVarChar, JobPosition.CreatedUser)
.SetParameter("Manager", SqlDbType.TinyInt, JobPosition.Manager)
.SetParameter("ModeifiedUser", SqlDbType.NVarChar, JobPosition.ModifiedUser)
.SetParameter("Status", SqlDbType.TinyInt, JobPosition.Status)
.SetParameter("ErrorCode", SqlDbType.NVarChar, DBNull.Value, 100, ParameterDirection.Output)
.SetParameter("ErrorMessage", SqlDbType.NVarChar, DBNull.Value, 4000, ParameterDirection.Output)
.ExcuteNonQuery()
.Complete();
db.GetOutValue("ErrorCode", out outCode)
.GetOutValue("ErrorMessage", out outMessage);
if (outCode != "0" || outCode == "")
{
result.Failed(outCode, outMessage);
}
else
{
result.Item = JobPosition;
result.ErrorCode = "0";
result.ErrorMessage = "";
}
}
catch (Exception ex)
{
result.Failed("-1", ex.Message);
}
return(result);
}
public void SetUp()
{
this.context = new Job4EveryoneDbContext(this.contextOptions);
var jobPosition = new JobPosition()
{
Name = "Job position"
};
var employer = new Employer()
{
UserName = "******"
};
this.context.JobPositions.Add(jobPosition);
this.context.Employers.Add(employer);
this.context.SaveChanges();
this.jobPositionId = jobPosition.Id;
this.employerUserName = employer.UserName;
this.employerId = employer.Id;
}
public static Responses Update(JobPositionViewModel entity)
{
Responses result = new Responses();
try
{
using (var db = new PayrollContext())
{
if (entity.Id != 0)
{
JobPosition jobposition = db.JobPosition.Where(o => o.Id == entity.Id).FirstOrDefault();
if (jobposition != null)
{
jobposition.Code = entity.Code;
jobposition.DepartmentId = entity.DepartmentId;
jobposition.Description = entity.Description;
jobposition.IsActivated = entity.IsActivated;
jobposition.ModifyBy = "Azam";
jobposition.ModifyDate = DateTime.Now;
db.SaveChanges();
}
}
else
{
JobPosition jobposition = new JobPosition();
jobposition.Code = entity.Code;
jobposition.DepartmentId = entity.DepartmentId;
jobposition.Description = entity.Description;
jobposition.IsActivated = entity.IsActivated;
jobposition.CreateBy = "Azam";
jobposition.CreateDate = DateTime.Now;
db.JobPosition.Add(jobposition);
db.SaveChanges();
}
}
}
catch (Exception ex)
{
result.Message = ex.Message;
result.Success = false;
}
return(result);
}
public void CreateAsync_ReturnsCorrectEmployeeId()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>().UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
using (var dbContext = new ApplicationDbContext(options))
{
JobPosition jobPosition = new JobPosition()
{
Name = "newJobPos",
};
dbContext.JobPositions.Add(jobPosition);
dbContext.SaveChanges();
OperatingLocation operatingLocation = new OperatingLocation()
{
Town = "Sofia",
Address = "test street",
ImageUrl = "kgkkkgk",
};
dbContext.OperatingLocations.Add(operatingLocation);
dbContext.SaveChanges();
CreateEmployeeServiceModel employee = new CreateEmployeeServiceModel
{
FirstName = "Ivan",
MiddleName = "Ivanov",
LastName = "Ivanov",
Phone = "0897924218",
Email = "*****@*****.**",
Town = "Sofia",
Address = "address 1",
ImageUrl = "aasdfag",
OperatingLocationId = operatingLocation.Id,
JobPositionId = jobPosition.Id,
};
var employeesService = new EmployeesService(dbContext);
var result = employeesService.CreateAsync(employee);
var employeeObj = dbContext.Employees.FirstOrDefaultAsync();
Assert.Equal(employeeObj.Result.Id, result.Result);
}
}
public static RulePoint GetPoint(CalculationData data, JobPosition job, string indexName, string name)
{
try
{
RulePoint res = null;
if (data.Points.JobResults.ContainsKey(job.DictionaryName))
{
if (data.Points.JobResults[job.DictionaryName].IndexResults.ContainsKey(indexName))
{
res = data.Points.JobResults[job.DictionaryName].IndexResults[indexName].SingleOrDefault(j => j.Name == name);
}
}
return(res);
}
catch (Exception ex)
{
throw exceptionConvertor(ex, name);
}
}
// GET: JobPositions/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
JobPosition jobPosition = db.Jobs.Find(id);
if (jobPosition == null)
{
return(HttpNotFound());
}
var companies = db.UserCompanies.Where(w => w.User.UserName == User.Identity.Name).Select(s => s.CompanyId).Distinct().ToList();
ViewBag.CompanyId = new SelectList(db.Companies.Where(w => companies.Contains((int)w.CompanyId)), "CompanyId", "Name", jobPosition.CompanyId);
return(PartialView("_Edit", jobPosition));
}
public ActionResult Add(JobPosition jobPosition, string skill)
{
if (ModelState.IsValid)
{
if (jobPosition.Title != null)
{
if (!db.positions.Select(x => x.Title).Contains(jobPosition.Title))
{
jobPosition.Status = true;
db.positions.Add(jobPosition);
db.SaveChanges();
}
}
if (!string.IsNullOrWhiteSpace(skill))
{
if (!db.skilss.Select(x => x.Skill).Contains(skill))
{
var skils = new Skills()
{
status = true, Skill = skill
};
db.skilss.Add(skils);
db.SaveChanges();
}
}
var h = (int?)TempData["value"];
var k = (int?)TempData["skill"];
if (h.HasValue)
{
return(RedirectToAction("AddEmployee", "Employee"));
}
else if (k.HasValue)
{
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("Index"));
}
}
return(View(jobPosition));
}
public static int Save(JobPosition job)
{
int result;
MyDBConnection myConn = new MyDBConnection();
SqlConnection conn = new SqlConnection();
try
{
conn = myConn.OpenDB();
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "dbo.InsertJobPosition";
if (job.PositionID == -1)
{
cmd.Parameters.Add("@PositionID", SqlDbType.Int).Value = DBNull.Value;
}
else
{
cmd.Parameters.Add("@PositionID", SqlDbType.Int).Value = job.PositionID;
}
cmd.Parameters.Add("@PositionName", SqlDbType.VarChar).Value = job.PositionName;
cmd.Parameters.Add("@CreatedBy", SqlDbType.VarChar).Value = job.CreatedBy;
cmd.Parameters.Add("@CreatedDate", SqlDbType.DateTime).Value = job.CreatedDate;
cmd.Parameters.Add("@ModifiedDate", SqlDbType.DateTime).Value = job.ModifiedDate;
cmd.Parameters.Add("@ModifiedBy", SqlDbType.VarChar).Value = job.ModifiedBy;
DbParameter returnValue = cmd.CreateParameter();
returnValue.Direction = ParameterDirection.ReturnValue;
cmd.Parameters.Add(returnValue);
cmd.ExecuteNonQuery();
result = Convert.ToInt32(returnValue.Value);
}
finally
{
myConn.CloseDB(conn);
}
return(result);
}
/// <summary>
/// Page's load event
/// </summary>
/// <param name="sender">Loaded page</param>
/// <param name="e">Event's arguments</param>
protected void Page_Load(object sender, EventArgs e)
{
if (Session["User"] == null)
{
this.Response.Redirect("Default.aspx");
}
if (this.Request.QueryString["id"] != null)
{
this.cargoId = Convert.ToInt32(this.Request.QueryString["id"].ToString());
}
this.company = (Company)Session["company"];
this.dictionary = Session["Dictionary"] as Dictionary <string, string>;
if (cargoId > 0)
{
this.cargo = new JobPosition(this.cargoId, this.company.Id);
this.LtModificado.Text = string.Format("<strong>{0}</strong><br />{1}", this.cargo.ModifiedBy.FullName, this.cargo.ModifiedOn);
}
else
{
this.cargo = JobPosition.Empty;
this.LtModificado.Text = string.Format("<i>({0})</i>", this.dictionary["Nuevo"]);
}
string label = this.cargoId == -1 ? "Nuevo cargo" : "Editar cargo";
this.master = this.Master as Giso;
string serverPath = this.Request.Url.AbsoluteUri.Replace(this.Request.RawUrl.Substring(1), string.Empty);
this.master.AddBreadCrumb("Cargos", "CargosList.aspx", false);
this.master.AddBreadCrumb(label);
this.master.Titulo = label;
if (!IsPostBack)
{
this.RenderEmployees();
this.RenderDepartamentos();
this.GetEmployeeDepartmentMemberShip();
}
}
