Пример #1
0
        public async Task <IActionResult> PostWorkExperience([FromBody] WorkExperience workExperience)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            _context.WorkExperience.Add(workExperience);
            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                if (WorkExperienceExists(workExperience.WorkExperienceId))
                {
                    return(new StatusCodeResult(StatusCodes.Status409Conflict));
                }
                else
                {
                    throw;
                }
            }

            return(CreatedAtAction("GetWorkExperience", new { id = workExperience.WorkExperienceId }, workExperience));
        }
Пример #2
0
        public IEnumerable <WorkExperience> Experiences()
        {
            var gmi = new WorkExperience
            {
                Title       = "General Mills",
                Description = "Fortune 100",
                Subtitle    = "Fortune 100",
                Route       = "/generalmills",
                ClassName   = "gmi"
            };
            var sparkstarter = new WorkExperience
            {
                Title       = "Sparkstarter",
                Description = "Fortune 100",
                Subtitle    = "Mobile Startup",
                Route       = "/sparkstarter",
                ClassName   = "sparkstarter"
            };
            var gehealthcare = new WorkExperience
            {
                Title       = "GE Healthcare",
                Description = "Fortune 100",
                Subtitle    = "Fortune 100",
                Route       = "/gehealthcare",
                ClassName   = "gehealthcare"
            };
            var exp = new[] { gmi, sparkstarter, gehealthcare };

            return(exp);
        }
Пример #3
0
        public ActionResult EditWorkExperience(WorkExperience wExp)
        {
            UnitOfWork.WorkExperienceManager.Update(wExp);
            ApplicationUser user = UnitOfWork.ApplicationUserManager.FindById(User.Identity.GetUserId());

            return(RedirectToAction("index", user));
        }
Пример #4
0
        public ActionResult AddWorkExperience(WorkExperienceViewModel workExpVM)
        {
            if (ModelState.IsValid)
            {
                workExpVM.Company.PlaceType = PlaceType.Company;
                UnitOfWork.SavedPlaceManager.Add(workExpVM.Company);
                WorkExperience workExp = new WorkExperience {
                    UserId         = User.Identity.GetUserId(),
                    Title          = workExpVM.Title,
                    Location       = workExpVM.Location,
                    Description    = workExpVM.Description,
                    EmploymentType = workExpVM.EmploymentType,
                    CompanyId      = workExpVM.Company.Id,
                    StartDate      = new DateTime(workExpVM.StartYear, workExpVM.StartMonth, 1)
                };
                if (workExpVM.EndMonth != null && workExpVM.EndYear != null)
                {
                    workExp.EndDate = new DateTime((int)workExpVM.EndYear, (int)workExpVM.EndMonth, 1);
                }

                UnitOfWork.WorkExperienceManager.Add(workExp);
                return(PartialView("__AddExperienceCard", workExp));
            }

            return(View("Index"));
        }
        public async Task <WorkExperience> UpdateWorkExperience(WorkExperience workExperience)
        {
            DbContext.WorkExperience.Update(workExperience);
            await DbContext.SaveChangesAsync();

            return(workExperience);
        }
        public async Task <IActionResult> Edit(int id, [Bind("ID,Title,Job_Type,Company,FromDate,ToDate,Description,Responsibilities")] WorkExperience workExperience)
        {
            if (id != workExperience.ID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(workExperience);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WorkExperienceExists(workExperience.ID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(workExperience));
        }
        public async Task GetByIdAsync_WorksCorrectly()
        {
            string expectedResult = "PositionTest";

            var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
                                                 .UseInMemoryDatabase(Guid.NewGuid().ToString())
                                                 .Options);

            var model = new WorkExperience()
            {
                Position  = expectedResult,
                Institute = "InstituteTest",
                From      = 2000,
                To        = 2001,
                Resume    = new Resume()
            };

            await context.AddAsync(model);

            context.SaveChanges();

            var workService = new WorkHistoryService(new EfRepository <Resume>(context),
                                                     new EfRepository <WorkExperience>(context));

            var result = await workService.GetByIdAsync(model.Id);

            Assert.Equal(expectedResult, result.Position);
        }
        public async Task RemoveExistingWorkExperience_ReturnsTrue()
        {
            var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
                                                 .UseInMemoryDatabase(Guid.NewGuid().ToString())
                                                 .Options);

            var model = new WorkExperience()
            {
                Position  = "PositionTest",
                Institute = "InstituteTest",
                From      = 2000,
                To        = 2001,
            };

            await context.AddAsync(model);

            context.SaveChanges();

            var workService = new WorkHistoryService(new EfRepository <Resume>(context),
                                                     new EfRepository <WorkExperience>(context));

            var result = await workService.RemoveWorkExperience(model.Id);

            Assert.True(result);

            var dbModels = await context.WorksHistory.AnyAsync();

            Assert.False(dbModels);
        }
        public ActionResult editWorkExperience(WorkExperience std)
        {
            WorkExperience toEdit = db.WorkExperiences.Where(a => a.id == std.id).FirstOrDefault();

            if (toEdit == null)
            {
                return(Json("No Matching record"));
            }
            toEdit.Position             = std.Position;
            toEdit.Description          = std.Description;
            toEdit.From                 = std.From;
            toEdit.To                   = std.To;
            toEdit.LastModificationDate = DateTime.Now;
            db.Entry(toEdit).State      = EntityState.Modified;
            try { db.SaveChanges(); }
            catch (DbEntityValidationException e)
            {
                string message1 = e.StackTrace;
                foreach (var eve in e.EntityValidationErrors)
                {
                    message1 += eve.Entry.State + "\n";
                    foreach (var ve in eve.ValidationErrors)
                    {
                        message1 += String.Format("- Property: \"{0}\", Error: \"{1}\"",
                                                  ve.PropertyName, ve.ErrorMessage);
                        message1 += "\n";
                    }
                }
                return(Json(new { Message = message1, JsonRequestBehavior.AllowGet }));
            }

            string message = "SUCCESS";

            return(Json(new { Message = message, JsonRequestBehavior.AllowGet }));
        }
Пример #10
0
        public Guid createJobHistory(WorkExperience JobHistory)
        {
            context.JobHistorys.Add(JobHistory);
            context.SaveChanges();

            return(JobHistory.Id);
        }
Пример #11
0
        public ActionResult AddExperience(WorkExperience work, string id, UserWorkExperience userwork)
        {
            //userwork.UserID = D);
            var current = context.Users.FirstOrDefault(u => u.Id == id);

            // context.WorkExperiences.Add(work);
            context.Entry(work).State = EntityState.Added;

            userwork.UserID           = current.Id;
            userwork.WorkExperienceID = work.ID;

            //  context.UserWorkExperiences.Add(userwork);
            context.Entry(userwork).State = EntityState.Added;
            //var nn = context.UserWorkExperiences.FirstOrDefault(u => u.WorkExperienceID == work.ID);

            context.SaveChanges();
            //  return PartialView("GetExperiences", context.WorkExperiences.ToList());

            var we = context.UserWorkExperiences.Where(w => w.UserID == current.Id).ToList();
            List <WorkExperience> cur_workExp = new List <WorkExperience>();

            foreach (var item in we)
            {
                cur_workExp.Add(context.WorkExperiences.FirstOrDefault(w => w.ID == item.WorkExperienceID));
            }
            return(PartialView("GetExperiences", cur_workExp));
        }
        public static void Add(WorkExperience workExperience)
        {
            using (ApplicationDbContext db = new ApplicationDbContext())
            {

                try
                {
                    // Your code...
                    // Could also be before try if you know the exception occurs in SaveChanges

                    db.WorkExperiences.Add(workExperience);
                    db.SaveChanges();
                }
                catch (DbEntityValidationException e)
                {
                    foreach (var eve in e.EntityValidationErrors)
                    {
                        Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                            eve.Entry.Entity.GetType().Name, eve.Entry.State);
                        foreach (var ve in eve.ValidationErrors)
                        {
                            Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                                ve.PropertyName, ve.ErrorMessage);
                        }
                    }
                    throw;
                }

            }
        }
Пример #13
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,CompanyName,Position,StartTime,EndTime,JobType,UserId")] WorkExperience workExperience)
        {
            if (id != workExperience.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(workExperience);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WorkExperienceExists(workExperience.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["UserId"] = new SelectList(_context.ApplicationUser, "Id", "Id", workExperience.UserId);
            return(View(workExperience));
        }
Пример #14
0
        // GET: WorkExperience/Create
        public ActionResult Create(int id)
        {
            var education = new WorkExperience();

            education.PersonId = id;
            return(View(education));
        }
Пример #15
0
        public ActionResult Save(WorkExperience workExperience)
        {
            if (!ModelState.IsValid)
            {
                var viewModel = new WorkExperiencesFormViewModel(workExperience);
                return(View("WorkExperiencesForm", viewModel));
            }

            if (workExperience.Id == 0)
            {
                _context.WorkExperiences.Add(workExperience);
            }
            else
            {
                var workExperienceInDb = _context.WorkExperiences.Single(w => w.Id == workExperience.Id);

                workExperienceInDb.Company           = workExperience.Company;
                workExperienceInDb.Years             = workExperience.Years;
                workExperienceInDb.ReasonOfDeparture = workExperience.ReasonOfDeparture;
            }


            _context.SaveChanges();

            return(RedirectToAction("Index", "WorkExperiences", new { id = workExperience.PersonId }));
        }
Пример #16
0
        public async Task <IActionResult> EditResume(ResumeViewModel viewModel)
        {
            FilledResume filledResume = new FilledResume();

            filledResume.UserInfo         = viewModel.UserInfo;
            filledResume.StreamId         = _streamService.GetStreamByFullName(viewModel.StreamFullName).Id;
            filledResume.ResumeId         = viewModel.ResumeId;
            filledResume.Summary          = viewModel.Summary;
            filledResume.Skills           = viewModel.Skills;
            filledResume.ForeignLanguages = viewModel.ForeignLanguages;
            filledResume.Educations       = viewModel.Educations;
            filledResume.Courses          = viewModel.Courses;
            filledResume.Certificates     = viewModel.Certificates;
            filledResume.Exams            = viewModel.Exams;

            WorkExperience[] workExperiences = new WorkExperience[viewModel.WorkExperiences.Length];

            for (int i = 0; i < viewModel.WorkExperiences.Count(); i++)
            {
                workExperiences[i] = viewModel.WorkExperiences[i].ToWorkExperience();
            }

            filledResume.WorkExperiences = workExperiences;
            filledResume.Portfolios      = viewModel.Portfolios;
            filledResume.MilitaryStatus  = viewModel.MilitaryStatus;
            filledResume.AdditionalInfo  = viewModel.AdditionalInfo;
            filledResume.Recommendations = viewModel.Recommendations;

            await _editResumeService.SaveFullResumeAsync(filledResume);

            return(RedirectToAction(nameof(ResumeReviewController.Index), "ResumeReview", new { resumeId = viewModel.ResumeId }));
        }
        public async Task <IActionResult> Edit(int id, [Bind("WorkExepienceId,YearsSinceLastPromotion,YearsWithCurrentManager,YearsInCurrentRole,YearsAtCompany,EmployeeNumber")] WorkExperience workExperience)
        {
            if (id != workExperience.WorkExepienceId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(workExperience);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WorkExperienceExists(workExperience.WorkExepienceId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(workExperience));
        }
Пример #18
0
        public async Task <IActionResult> Edit(WorkExperience model)
        {
            var header = this.Request.Headers["sec-fetch-site"];

            if (header == "none")
            {
                return(RedirectToAction("Index", "Advertisement"));
            }
            if (ModelState.IsValid)
            {
                WorkExperience entity = db.WorkExperiences.FirstOrDefault(e => e.Id == model.Id);
                entity.CompanyName = model.CompanyName;
                entity.StartYear   = model.StartYear;
                entity.EndYear     = model.EndYear;
                entity.Title       = model.Title;
                entity.Description = model.Description;
                db.Update <WorkExperience>(entity);
                await db.SaveChangesAsync();

                toastNotification.AddSuccessToastMessage("Work Experience Updated !", new NotyOptions
                {
                    Theme   = "metroui",
                    Timeout = 1500,
                    Layout  = "topCenter"
                });
            }
            return(PartialView("_Edit", model));
        }
        public IActionResult AddWorkDetails(int?id, WorkExperience wca)
        {
            if (id == null)
            {
                return(StatusCode(StatusCodes.Status400BadRequest));
            }
            // retreive the target course from static field

            int?ApplicantId_ = HttpContext.Session.GetInt32(sessionId_);

            // this works too
            // int courseId_ = (int)TempData[sessionId_];

            var appli = context_.Applicant.Find(ApplicantId_);

            if (appli != null)
            {
                if (appli.academs == null)  // doesn't have any lectures yet
                {
                    List <WorkExperience> acade = new List <WorkExperience>();
                    appli.work = acade;
                }
                appli.work.Add(wca);

                try
                {
                    context_.SaveChanges();
                }
                catch (Exception)
                {
                    // do nothing for now
                }
            }
            return(RedirectToAction("Index"));
        }
        public async Task <IActionResult> Edit(int id, [Bind("WorkID,Position,Area,StartYear,EndYear,YearOfExperience,Description,UserID")] WorkExperience workExperience)
        {
            if (id != workExperience.WorkID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(workExperience);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WorkExperienceExists(workExperience.WorkID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["UserID"] = new SelectList(_context.Users, "UserID", "UserID", workExperience.UserID);
            return(View(workExperience));
        }
        public JsonResult deleteWorkExperience(int id)
        {
            WorkExperience toDelete = db.WorkExperiences.Where(a => a.id.Equals(id)).FirstOrDefault();

            db.WorkExperiences.Remove(toDelete);
            try { db.SaveChanges(); }
            catch (DbEntityValidationException e)
            {
                string message1 = e.StackTrace;
                foreach (var eve in e.EntityValidationErrors)
                {
                    message1 += eve.Entry.State + "\n";
                    foreach (var ve in eve.ValidationErrors)
                    {
                        message1 += String.Format("- Property: \"{0}\", Error: \"{1}\"",
                                                  ve.PropertyName, ve.ErrorMessage);
                        message1 += "\n";
                    }
                }
                return(Json(new { Message = message1, JsonRequestBehavior.AllowGet }));
            }

            string message = "SUCCESS";

            return(Json(new { Message = message, JsonRequestBehavior.AllowGet }));
        }
Пример #22
0
        public async Task <IActionResult> Edit(int id, [Bind("WorkExperienceId,CompanyName,JobTitle,WorkYears,CvId")] WorkExperience workExperience)
        {
            if (id != workExperience.WorkExperienceId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(workExperience);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WorkExperienceExists(workExperience.WorkExperienceId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["CvId"] = new SelectList(_context.Cvs, "CvId", "CvId", workExperience.CvId);
            return(View(workExperience));
        }
Пример #23
0
        public string AddOrUpdateExperience(WorkExperience workExperience, int idPer)
        {
            string msg = string.Empty;

            Person personEntity = _dbContext.People.Find(idPer);

            if (personEntity != null)
            {
                if (workExperience.IDExp > 0)
                {
                    //we will update work experience entity
                    _dbContext.Entry(workExperience).State = EntityState.Modified;
                    _dbContext.SaveChanges();

                    msg = "Work Experience entity has been updated successfully";
                }
                else
                {
                    // we will add new work experience entity
                    personEntity.WorkExperiences.Add(workExperience);
                    _dbContext.SaveChanges();

                    msg = "Work Experience entity has been Added successfully";
                }
            }

            return(msg);
        }
Пример #24
0
        public async Task <IActionResult> Edit(int id, [Bind("WorkExperienceId,Durée,EndDate,Entreprise,Position,StartDate,idUser,photo")] WorkExperience workExperience)
        {
            if (id != workExperience.WorkExperienceId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(workExperience);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WorkExperienceExists(workExperience.WorkExperienceId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction("Index"));
            }
            ViewData["idUser"] = new SelectList(_context.AppUSers, "Id", "Id", workExperience.idUser);
            return(View(workExperience));
        }
Пример #25
0
        public string AddOrUpdateExperience(WorkExperience workExperience, int IdPerson)
        {
            string msg = "";

            Person person = DB.People.Find(IdPerson);

            if (person != null)
            {
                if (workExperience.IDexperience > 0)
                {
                    DB.Entry(workExperience).State = System.Data.Entity.EntityState.Modified;
                    DB.SaveChanges();
                    msg = "Work Experience Updated";
                }
                else
                {
                    person.WorkExperiences.Add(workExperience);
                    DB.SaveChanges();
                    msg = "work Experience Added";
                }
            }

            return(msg);
            //throw new NotImplementedException();
        }
 protected void btnWorkExpDelete_Click(object sender, EventArgs e)
 {
     try
     {
         _presenter.CurrentAppUser.Employee.RemoveWorkExperience(Convert.ToInt32(Session["workExpId"]));
         WorkExperience delWorkExp = _presenter.GetWorkExperience(Convert.ToInt32(Session["workExpId"]));
         if (delWorkExp != null)
         {
             _presenter.DeleteWorkExperience(delWorkExp);
         }
         _presenter.SaveOrUpdateEmployee(_presenter.CurrentAppUser);
         Session["workExpId"] = null;
         //Clear the fields
         clearWorkExperiences();
         BindWorkExperiences();
         btnWorkExpDelete.Enabled = false;
         Master.ShowMessage(new AppMessage("Work Experience Is Successfully Deleted!", RMessageType.Info));
         ScriptManager.RegisterStartupScript(this.Page, this.GetType(), "script", "movetowork();", true);
     }
     catch (Exception ex)
     {
         Master.ShowMessage(new AppMessage("Error: While Deleting Work Experience!", RMessageType.Error));
         ExceptionUtility.LogException(ex, ex.Source);
         ExceptionUtility.NotifySystemOps(ex, _presenter.CurrentUser().FullName);
     }
 }
        public IActionResult EditWorkDetails(int?id, WorkExperience lct)
        {
            if (id == null)
            {
                return(StatusCode(StatusCodes.Status400BadRequest));
            }
            var adp = context_.WorkEx.Find(id);

            if (adp != null)
            {
                adp.Company           = lct.Company;
                adp.JobTitle          = lct.JobTitle;
                adp.No_Of_Years       = lct.No_Of_Years;
                adp.Responsibilites   = lct.Responsibilites;
                adp.Technologies_Used = lct.Technologies_Used;
                try
                {
                    context_.SaveChanges();
                }
                catch (Exception)
                {
                    // do nothing for now
                }
            }
            return(RedirectToAction("ReviewApplication"));
        }
Пример #28
0
        public async Task <IActionResult> PutWorkExperience([FromRoute] int id, [FromBody] WorkExperience workExperience)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != workExperience.WorkId)
            {
                return(BadRequest());
            }

            _context.Entry(workExperience).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!WorkExperienceExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #29
0
        public override string ToString()
        {
            string tmp = FIO + "\n\n" + "Образование:\n" + Education.GetEducationInfo() + "\n\n" +
                         "Опыт работы:\n" + WorkExperience.GetInfo();

            return(tmp);
        }
Пример #30
0
 //更新用户工作经历
 public bool Update(WorkExperience wex)
 {
     try
     {
         if (wex != null)
         {
             WorkExperience newwex = dbcontext.WorkExperienceContext.Find(wex.WorkExperienceID);
             //newwex.WorkExperienceID = wex.WorkExperienceID;
             newwex.PartTimeUnit = wex.PartTimeUnit;
             newwex.StartTime    = wex.StartTime;
             newwex.EndTime      = wex.EndTime;
             newwex.Post         = wex.Post;
             newwex.JobTitle     = wex.JobTitle;
             newwex.WorkUnit     = wex.WorkUnit;
             newwex.SecrecyLevel = wex.SecrecyLevel;
             newwex.Remark       = wex.Remark;
             newwex.UserInfoID   = wex.UserInfoID;
             dbcontext.SaveChanges();
             return(true);
         }
         else
         {
             return(false);
         }
     }
     catch (System.Data.SqlClient.SqlException e)
     {
         throw e;
     }
 }
Пример #31
0
        private void AddExperience_Click(object sender, RoutedEventArgs e)
        {
            var startExp    = userStartWorkExp.SelectedDate;
            var endExp      = userEndWorkExp.SelectedDate;
            var company     = userCompanyExp.Text;
            var description = userDescriptionExp.Text;

            if (WorkExperience.Validate(startExp, company, endExp, description))
            {
                if (repo.CurrentExperience == null)
                {
                    var experience = new WorkExperience {
                        Company = company, Description = description, EndDate = endExp, StartDate = (DateTime)startExp
                    };
                    repo.AddNewExperience(experience);
                }
                else
                {
                    repo.UpdateExperience((DateTime)startExp, company, endExp, description);
                    repo.CurrentExperience = null;
                }
                repo.SaveConfig();
                this.Close();
            }
            else
            {
                textIncorrectData.Text = "Введены неправильные данные";
            }
        }
Пример #32
0
 public Manager(Guid id, string name, string surname,WorkExperience work, string address, string phone, string login, string password)
     : base(id)
 {
     Name = name;
     Surname = surname;
     Address = address;
     Phone = phone;
     Login = login;
     Password = password;
     Work = work;
 }
Пример #33
0
        /// <summary>
        /// 更新工作经历
        /// </summary>
        /// <param name="workExperience"><see cref="WorkExperience"/></param>
        public void UpdateWorkExperience(WorkExperience workExperience)
        {
            if (workExperience == null) return;
            workExperienceRepository.Update(workExperience);

            UserProfile userProfile = profileRepository.Get(workExperience.UserId);
            EventBus<UserProfile>.Instance().OnAfter(userProfile, new CommonEventArgs(EventOperationType.Instance().Update()));
        }
Пример #34
0
        /// <summary>
        /// 添加工作经历
        /// </summary>
        /// <param name="workExperience"><see cref="WorkExperience"/></param>
        /// <returns>创建成功返回true,否则返回false</returns>
        public bool CreateWorkExperience(WorkExperience workExperience)
        {
            if (workExperience == null)
                return false;

            long affectId = Convert.ToInt64(workExperienceRepository.Insert(workExperience));

            UserProfile userProfile = profileRepository.Get(workExperience.UserId);
            EventBus<UserProfile>.Instance().OnAfter(userProfile, new CommonEventArgs(EventOperationType.Instance().Update()));

            if (affectId > 0)
            {
                profileRepository.UpdateIntegrity(workExperience.UserId);
                return true;
            }
            return false;
        }