Exemplo n.º 1
0
 public CVManager(EmployeeCVGenerationStats cvGenerationStats)
 {
     daysForNextCV          = cvGenerationStats.DaysBeforeFirstCV;
     this.cvGenerationStats = cvGenerationStats;
     PendingCV = null;
     resetDaysForNextCV();
 }
Exemplo n.º 2
0
 private void generateNewCV()
 {
     PendingCV = new EmployeeCV();
     if (OnNewCVGenerated != null)
     {
         OnNewCVGenerated();
     }
 }
Exemplo n.º 3
0
    private void OnNewCVGenerated()
    {
        EmployeeCV cv = GameMetaManager.CVs.PendingCV;

        cvNameText.text  = string.Format(cvText, cv.Name);
        cvMoneyText.text = string.Format(moneyText, cv.MoneyCost.ToString());
        cvMotivationBarImage.fillAmount = cv.Happiness;
        cvMotivationBarImage.sprite     = (cv.Happiness >= 0.75f ? barGreenSprite : (cv.Happiness >= 0.5f ? barOrangeSprite : barRedSprite));
        ShowCV(true);
    }
        public HttpResponseMessage uploadCv(int employeeID)
        {
            db.Configuration.ProxyCreationEnabled = false;
            try
            {
                string imageName   = null;
                var    httpRequest = HttpContext.Current.Request;

                //upload image
                var postedFile = httpRequest.Files["image"];

                //create custom filename
                imageName = new string(Path.GetFileNameWithoutExtension(postedFile.FileName).Take(10).ToArray()).Replace(" ", "-");
                imageName = imageName + DateTime.Now.ToString("yymmssff") + Path.GetExtension(postedFile.FileName);
                var filePath = HttpContext.Current.Server.MapPath("~/Images/" + imageName);
                postedFile.SaveAs(filePath);

                Employee employee = db.Employees.Where(z => z.EmployeeID == employeeID).FirstOrDefault();
                User     user     = db.Users.Where(z => z.UserID == employee.UserID).FirstOrDefault();
                //save to db
                using (OrdraDBEntities dbs = new OrdraDBEntities())
                {
                    EmployeeCV image = new EmployeeCV()
                    {
                        CVCaption  = user.UserName + " " + user.UserSurname + " CV",//httpRequest["ImageCaption"],
                        CVName     = imageName,
                        EmployeeID = employeeID,
                    };
                    db.EmployeeCVs.Add(image);
                    db.SaveChanges();
                }
            }
            catch (Exception error)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Error in saving the image: " + error));
            }

            return(Request.CreateResponse(HttpStatusCode.Created, "Saved successfully"));
        }
Exemplo n.º 5
0
        private static async Task CreateEmployeeCv(string userName, int id, string detail, string title, float salary, bool findJobStatus, DateTime startFindJobDate, int fieldId, bool primary, ApplicationDbContext _context)
        {
            var user  = _context.Users.First(a => a.Email == userName);
            var newCv = new EmployeeCV
            {
                Id = id, Details = detail, Title = title, EmployeeId = user.Id, MinSaraly = salary, FindJobStatus = findJobStatus, StartFindJobDate = startFindJobDate, FieldId = fieldId, Primary = primary
            };
            var check = _context.EmployeeCvs.Where(a => a.Id == id);

            if (check.Any())
            {
                return;
            }
            try
            {
                await _context.EmployeeCvs.AddAsync(newCv);

                await _context.SaveChangesAsync();
            }
            catch (Exception ex)
            {
            }
        }
        public async Task <RedirectToActionResult> EditCvAction(EditCVAction cv,
                                                                IEnumerable <EditCVEmployeeSkill> skills,
                                                                IEnumerable <EditCVExternalMeterial> externalMaterials,
                                                                IEnumerable <EditCVJobHistory> jobHistories,
                                                                IEnumerable <EditCvWorkDay> days)
        {
            InitialSystemInfo();
            if (!ModelState.IsValid)
            {
                ProcessModelState();
                return(RedirectToActionPermanent("EditCV", "Employee", new { CvId = cv.CvId }));
            }
            var user = await _userManager.GetUserAsync(User);

            EmployeeCV newCv      = null;
            var        newFieldId = 0;
            var        newSkills  = new List <EmployeeSkill>();

            //1. Validate if correct cv id
            if (cv.CvId != 0)
            {
                //Validate if is correct cv id
                try{
                    newCv = _context.EmployeeCvs.First(a => a.Id == cv.CvId);
                    //Validate if is current Employee's CV
                    if (newCv.EmployeeId != user.Id)
                    {
                        if ((string)TempData["Error"] != "")
                        {
                            TempData["Error"] += "\n";
                        }

                        TempData["Error"] += "Sorry. It is not your CV1!";
                        return(RedirectToActionPermanent("MyCVs"));
                    }
                }
                catch (InvalidOperationException)
                {
                    if ((string)TempData["Error"] != "")
                    {
                        TempData["Error"] += "\n";
                    }

                    TempData["Error"] += "Sorry. It is not your CV2!";
                    return(RedirectToAction("EditCV"));
                }
            }
            //2. Validate if correct field name
            try{
                //Get new CV field id
                newFieldId = _context.Fields.First(a =>
                                                   a.Status == FieldStatus.InUse &&
                                                   a.NormalizedName == cv.FieldName.ToUpper()
                                                   ).Id;
            }
            catch (InvalidOperationException)
            {
                if ((string)TempData["Error"] != "")
                {
                    TempData["Error"] += "\n";
                }
                TempData["Error"] += "Sorry. Not a valid field!";
                return(RedirectToAction("EditCV", new{ CvId = cv.CvId }));
            }
            //3. Validate skill name
            //!! No skill more than 10 skill
            foreach (var skill in skills)
            {
                try
                {
                    var newSkillId = _context.Skills
                                     .First(a =>
                                            a.NormalizedName == skill.SkillName.ToUpper())
                                     .Id;
                    newSkills.Add(new EmployeeSkill {
                        CertificationLink = skill.CertificationLink, SkillId = newSkillId
                    });
                }
                catch (InvalidCastException)
                {
                    if ((string)TempData["Error"] != "")
                    {
                        TempData["Error"] += "\n";
                    }
                    TempData["Error"] += "Sorry. " + skill.SkillName + " is not a valid skill";
                }
            }
            if (!newSkills.Any() || newSkills.ToList().Count > 10)
            {
                if ((string)TempData["Error"] != "")
                {
                    TempData["Error"] += "\n";
                }
                TempData["Error"] += "Sorry. At least one skill at most ten skill!";
                return(RedirectToAction("EditCV", new { CvId = cv.CvId }));
            }
            //Get new external materials
            var newExternalMaterials = externalMaterials.Select(externalMaterial => new EmployeeExternalMeterial {
                Name = externalMaterial.ExternalMaterialName, Link = externalMaterial.ExternalMaterialLink
            }).ToList();
            //GET NEW JOB HISTORIES
            var newJobHistories = jobHistories.Select(jobHistory => new EmployeeJobHistory {
                Name = jobHistory.JobHistoryName, ShortDescription = jobHistory.JobHistoryShortDescription
            }).ToList();
            //GET NEW Days
            var newDays = days.Select(day => new EmployeeWorkDay {
                Day = day.Day
            }).ToList();

            if (newCv == null)
            {
                if (newSkills.Any() && newFieldId != 0)
                {
                    newCv = new EmployeeCV
                    {
                        EmployeeId       = user.Id,
                        Primary          = cv.PrimaryCv,
                        FindJobStatus    = cv.UpdateStatus,
                        StartFindJobDate = DateTime.Now,
                        Title            = cv.Title,
                        Details          = cv.Description,
                        MinSaraly        = cv.MinSalary,
                        FieldId          = newFieldId
                    };
                    try
                    {
                        _context.EmployeeCvs.Update(newCv);
                        _context.SaveChanges();
                        if ((string)TempData["Success"] != "")
                        {
                            TempData["Success"] += "\n";
                        }
                        TempData["Success"] += "New Cv Added!";
                    }
                    catch (InvalidOperationException)
                    {
                        if ((string)TempData["Error"] != "")
                        {
                            TempData["Error"] += "\n";
                        }
                        TempData["Error"] += "Sorry. Failed to create a new cv!";
                        return(RedirectToAction("EditCV"));
                    }
                }
                else
                {
                    if ((string)TempData["Error"] != "")
                    {
                        TempData["Error"] += "\n";
                    }
                    TempData["Error"] += "Sorry. Failed to create a new cv!";
                    return(RedirectToAction("EditCV"));
                }
            }
            //TODO for
            foreach (var newSkill in newSkills)
            {
                newSkill.EmployeeCvId = newCv.Id;
            }
            foreach (var newExternalMaterial in newExternalMaterials)
            {
                newExternalMaterial.EmployeeCvId = newCv.Id;
            }
            foreach (var newJobHistory in newJobHistories)
            {
                newJobHistory.EmployeeCvId = newCv.Id;
            }
            foreach (var day in newDays)
            {
                day.EmployeeCvId = newCv.Id;
            }
            if (newCv.Primary != cv.PrimaryCv)
            {
                try
                {
                    var otherCvs = _context.EmployeeCvs.Where(a => a.EmployeeId == user.Id);
                    if (cv.PrimaryCv == true)
                    {
                        foreach (var otherCv in otherCvs)
                        {
                            otherCv.Primary = false;
                        }
                    }
                    newCv.Primary = cv.PrimaryCv;
                    _context.EmployeeCvs.UpdateRange(otherCvs);
                    _context.EmployeeCvs.Update(newCv);
                    _context.SaveChanges();
                    if ((string)TempData["Success"] != "")
                    {
                        TempData["Success"] += "\n";
                    }
                    TempData["Success"] += "Primary Cv status changed.";
                }
                catch (InvalidOperationException)
                {
                    if ((string)TempData["Error"] != "")
                    {
                        TempData["Error"] += "\n";
                    }

                    TempData["Error"] += "Sorry. Failed to update primary cv status!";
                }
            }

            if (cv.UpdateStatus != newCv.FindJobStatus)
            {
                if (cv.UpdateStatus == true)
                {
                    try
                    {
                        newCv.StartFindJobDate = DateTime.Now;
                        newCv.FindJobStatus    = true;
                        _context.EmployeeCvs.Update(newCv);
                        _context.SaveChanges();
                        if ((string)TempData["Success"] != "")
                        {
                            TempData["Success"] += "\n";
                        }
                        TempData["Success"] += "Start to find job!";
                    }
                    catch (InvalidOperationException)
                    {
                        if ((string)TempData["Error"] != "")
                        {
                            TempData["Error"] += "\n";
                        }

                        TempData["Error"] += "Sorry. Failed to update find job status";
                    }
                }
                else
                {
                    try
                    {
                        newCv.FindJobStatus    = false;
                        newCv.StartFindJobDate = DateTime.MinValue;
                        _context.EmployeeCvs.Update(newCv);
                        _context.SaveChanges();
                        if ((string)TempData["Success"] != "")
                        {
                            TempData["Success"] += "\n";
                        }
                        TempData["Success"] += "Stop to find job!";
                    }
                    catch (InvalidOperationException)
                    {
                        if ((string)TempData["Error"] != "")
                        {
                            TempData["Error"] += "\n";
                        }

                        TempData["Error"] += "Sorry. Failed to update find job status";
                    }
                }
            }



            if (newCv.Title != cv.Title)
            {
                try
                {
                    newCv.Title = cv.Title;
                    _context.EmployeeCvs.Update(newCv);
                    _context.SaveChanges();
                    if ((string)TempData["Success"] != "")
                    {
                        TempData["Success"] += "\n";
                    }
                    TempData["Success"] += "CV's title changed!";
                }
                catch (InvalidOperationException)
                {
                    if ((string)TempData["Error"] != "")
                    {
                        TempData["Error"] += "\n";
                    }

                    TempData["Error"] += "Sorry. Failed to update title";
                }
            }

            if (newCv.Details != cv.Description)
            {
                try
                {
                    newCv.Details = cv.Description;
                    _context.EmployeeCvs.Update(newCv);
                    _context.SaveChanges();
                    if ((string)TempData["Success"] != "")
                    {
                        TempData["Success"] += "\n";
                    }
                    TempData["Success"] += "CV's description changed!";
                }
                catch (InvalidOperationException)
                {
                    if ((string)TempData["Error"] != "")
                    {
                        TempData["Error"] += "\n";
                    }

                    TempData["Error"] += "Sorry. Failed to update description";
                }
            }

            if (!Math.Abs(newCv.MinSaraly - cv.MinSalary).Equals(0))
            {
                try
                {
                    newCv.MinSaraly = cv.MinSalary;
                    _context.EmployeeCvs.Update(newCv);
                    _context.SaveChanges();
                    if ((string)TempData["Success"] != "")
                    {
                        TempData["Success"] += "\n";
                    }
                    TempData["Success"] += "CV's min salary changed!";
                }
                catch (InvalidOperationException)
                {
                    if ((string)TempData["Error"] != "")
                    {
                        TempData["Error"] += "\n";
                    }

                    TempData["Error"] += "Sorry. Failed to update min salary";
                }
            }
            //Update CV's field
            try
            {
                var oldFieldId = _context.Fields.First(a =>
                                                       a.Id == newCv.FieldId
                                                       ).Id;
                //Check if new field
                if (newFieldId != oldFieldId)
                {
                    //Update existed cv's field
                    try
                    {
                        newCv.FieldId = newFieldId;
                        _context.EmployeeCvs.Update(newCv);
                        _context.SaveChanges();
                        if ((string)TempData["Success"] != "")
                        {
                            TempData["Success"] += "\n";
                        }
                        TempData["Success"] += "CV's field updated!";
                    }
                    catch (InvalidCastException)
                    {
                        if ((string)TempData["Error"] != "")
                        {
                            TempData["Error"] += "\n";
                        }
                        TempData["Error"] += "Sorry. Failed to change field! Please retry!";
                    }
                }
            }
            catch (InvalidOperationException)
            {
                if ((string)TempData["Error"] != "")
                {
                    TempData["Error"] += "\n";
                }
                TempData["Error"] += "Sorry. Failed to change field! Please retry!";
            }
            //Update skills
            try
            {
                var oldSkills     = _context.EmployeeSkills.Where(a => a.EmployeeCvId == newCv.Id).ToList();
                var newEnumerable = newSkills.Select(a => new { Link = a.CertificationLink, Id = a.SkillId }).OrderBy(a => a.Id);
                var oldEnumerable = oldSkills.Select(a => new { Link = a.CertificationLink, Id = a.SkillId }).OrderBy(a => a.Id);
                if (newEnumerable == oldEnumerable)
                {
                    try
                    {
                        if (oldSkills.Any())
                        {
                            _context.EmployeeSkills.RemoveRange(oldSkills);
                        }
                        _context.EmployeeSkills.AddRange(newSkills);
                        _context.SaveChanges();
                        if ((string)TempData["Success"] != "")
                        {
                            TempData["Success"] += "\n";
                        }
                        TempData["Success"] += "CV's skills updated!";
                    }
                    catch (InvalidCastException)
                    {
                        if ((string)TempData["Error"] != "")
                        {
                            TempData["Error"] += "\n";
                        }
                        TempData["Error"] += "Sorry. Failed to update your skills please retry";
                    }
                }
            }
            catch (InvalidOperationException)
            {
                if ((string)TempData["Error"] != "")
                {
                    TempData["Error"] += "\n";
                }
                TempData["Error"] += "Sorry. Failed to update your skills please retry";
            }
            //New external materials
            try
            {
                var cvId = newCv.Id;
                var oldExternalMaterials = _context.EmployeeExternalMeterials.Where(a => a.EmployeeCvId == cvId);
                var newEnumerable        = newExternalMaterials.Select(a => new { Name = a.Name, Link = a.Link }).OrderBy(a => a.Name).ToList();
                var oldEnumerable        = oldExternalMaterials.Select(a => new { Name = a.Name, Link = a.Link }).OrderBy(a => a.Name).ToList();
                var except = newEnumerable.Except(oldEnumerable);
                if (except.Any())
                {
                    try
                    {
                        _context.EmployeeExternalMeterials.RemoveRange(oldExternalMaterials);
                        if (newExternalMaterials.Any())
                        {
                            _context.EmployeeExternalMeterials.AddRange(newExternalMaterials);
                        }
                        _context.SaveChanges();
                        if ((string)TempData["Success"] != "")
                        {
                            TempData["Success"] += "\n";
                        }
                        TempData["Success"] += "CV's external material updated!";
                    }
                    catch (InvalidOperationException)
                    {
                        if ((string)TempData["Error"] != "")
                        {
                            TempData["Error"] += "\n";
                        }
                        TempData["Error"] += "Sorry. Failed to update your external material please retry";
                    }
                }
            }
            catch (InvalidOperationException)
            {
                if ((string)TempData["Error"] != "")
                {
                    TempData["Error"] += "\n";
                }
                TempData["Error"] += "Sorry. Failed to update your external material please retry";
            }
            //New Job histories
            try
            {
                var cvId            = newCv.Id;
                var oldJobHistories = _context.EmployeeJobHistories.Where(a => a.EmployeeCvId == cvId);
                var newEnumerable   = newJobHistories.Select(a => new { Name = a.Name, Link = a.ShortDescription }).OrderBy(a => a.Name).ToList();
                var oldEnumerable   = oldJobHistories.Select(a => new { Name = a.Name, Link = a.ShortDescription }).OrderBy(a => a.Name).ToList();
                var except          = newEnumerable.Except(oldEnumerable);
                if (except.Any())
                {
                    try
                    {
                        _context.EmployeeJobHistories.RemoveRange(oldJobHistories);
                        if (newJobHistories.Any())
                        {
                            _context.EmployeeJobHistories.AddRange(newJobHistories);
                        }
                        _context.SaveChanges();
                        if ((string)TempData["Success"] != "")
                        {
                            TempData["Success"] += "\n";
                        }
                        TempData["Success"] += "CV's job histories updated!";
                    }
                    catch (InvalidOperationException)
                    {
                        if ((string)TempData["Error"] != "")
                        {
                            TempData["Error"] += "\n";
                        }
                        TempData["Error"] += "Sorry. Failed to update your job histories please retry";
                    }
                }
            }
            catch (InvalidOperationException)
            {
                if ((string)TempData["Error"] != "")
                {
                    TempData["Error"] += "\n";
                }
                TempData["Error"] += "Sorry. Failed to update your job histories please retry";
            }
            //New Days
            try
            {
                var cvId          = newCv.Id;
                var oldDays       = _context.EmployeeWorkDays.Where(a => a.EmployeeCvId == cvId);
                var newEnumerable = newDays.Select(a => new { Day = a.Day }).OrderBy(a => a.Day).ToList();
                var oldEnumerable = oldDays.Select(a => new { Day = a.Day }).OrderBy(a => a.Day).ToList();
                var except        = newEnumerable.Except(oldEnumerable);
                if (except.Any())
                {
                    try
                    {
                        _context.EmployeeWorkDays.RemoveRange(oldDays);
                        if (newDays.Any())
                        {
                            _context.EmployeeWorkDays.AddRange(newDays);
                        }
                        _context.SaveChanges();
                        if ((string)TempData["Success"] != "")
                        {
                            TempData["Success"] += "\n";
                        }
                        TempData["Success"] += "CV's work day updated!";
                    }
                    catch (InvalidOperationException)
                    {
                        if ((string)TempData["Error"] != "")
                        {
                            TempData["Error"] += "\n";
                        }
                        TempData["Error"] += "Sorry. Failed to update your work day please retry";
                    }
                }
            }
            catch (InvalidOperationException)
            {
                if ((string)TempData["Error"] != "")
                {
                    TempData["Error"] += "\n";
                }
                TempData["Error"] += "Sorry. Failed to update your work day please retry";
            }

            return(RedirectToAction("EditCV", new { CvId = cv.CvId }));
        }
Exemplo n.º 7
0
 public void RejectPendingCV()
 {
     PendingCV = null;
     resetDaysForNextCV();
 }
Exemplo n.º 8
0
 public void AcceptPendingCV()
 {
     PendingCV = null;
     resetDaysForNextCV();
 }