public async Task <IActionResult> EditResume([FromRoute] string resumeId, [FromBody] FileEditDto dto)
        {
            FileEditDtoValidator validator = new FileEditDtoValidator();
            ValidationResult     result    = await validator.ValidateAsync(dto);

            if (result.IsValid)
            {
                var userId = User.Claims
                             .Single(p => p.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier").Value;
                var entity = await _dbContext.FileResumes
                             .Where(x => x.ApplicationUserId == userId)
                             .SingleOrDefaultAsync(x => x.FileResumeId == resumeId);

                if (entity == null)
                {
                    return(NotFound());
                }
                var updateEntity = _mapper.Map(dto, entity);
                _dbContext.FileResumes.Update(updateEntity);
                await _dbContext.SaveChangesAsync();

                var returnDto = _mapper.Map <FileDto>(updateEntity);
                return(CreatedAtRoute(nameof(GetResume), new { resumeId = returnDto.Id }, returnDto));
            }
            return(BadRequest(result.Errors));
        }
        protected virtual async Task Update(FileEditDto input)
        {
            //TODO:更新前的逻辑判断,是否允许更新

            var entity = await _entityRepository.GetAsync(input.Id.Value);

            input.MapTo(entity);

            // ObjectMapper.Map(input, entity);
            await _entityRepository.UpdateAsync(entity);
        }
        protected virtual async Task <FileEditDto> Create(FileEditDto input)
        {
            //TODO:新增前的逻辑判断,是否允许新增

            // var entity = ObjectMapper.Map <File>(input);
            var entity = input.MapTo <File>();


            entity = await _entityRepository.InsertAsync(entity);

            return(entity.MapTo <FileEditDto>());
        }
        public async Task <GetFileForEditOutput> GetForEdit(NullableIdDto <long> input)
        {
            var         output = new GetFileForEditOutput();
            FileEditDto editDto;

            if (input.Id.HasValue)
            {
                var entity = await _entityRepository.GetAsync(input.Id.Value);

                editDto = entity.MapTo <FileEditDto>();

                //fileEditDto = ObjectMapper.Map<List<fileEditDto>>(entity);
            }
            else
            {
                editDto = new FileEditDto();
            }

            output.File = editDto;
            return(output);
        }
        public async Task <IActionResult> EditRecruitmentFile([FromRoute] string campaignId, [FromRoute] string recruitmentId, [FromRoute] string fileId, [FromBody] FileEditDto dto)
        {
            FileEditDtoValidator validator = new FileEditDtoValidator();
            ValidationResult     result    = await validator.ValidateAsync(dto);

            if (result.IsValid)
            {
                var userId = User.Claims
                             .Single(p => p.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier").Value;
                var administrator = await _dbContext.Administrators
                                    .AsNoTracking()
                                    .SingleOrDefaultAsync(x => x.ApplicationUserId == userId);

                #region 驗證

                if (!administrator.AdministratorConfirmed)
                {
                    return(Problem(title: "禁止修改", detail: "管理員尚未驗證", statusCode: 403));
                }

                #endregion

                var act = await _dbContext.RecruitmentCampaigns
                          .Include(x => x.RecruitmentCampaignFiles)
                          .SingleOrDefaultAsync(x => x.CampaignId == campaignId && x.RecruitmentCampaignId == recruitmentId);

                if (act == null)
                {
                    return(NotFound());
                }

                var entity = act.RecruitmentCampaignFiles
                             .SingleOrDefault(x => x.RecruitmentCampaignFileId == fileId);
                if (entity == null)
                {
                    return(NotFound());
                }

                var updateEntity = _mapper.Map(dto, entity);
                _dbContext.RecruitmentCampaignFiles.Update(updateEntity);
                await _dbContext.SaveChangesAsync();

                var routeValues = new { campaignId = act.CampaignId, recruitmentId = act.RecruitmentCampaignId, fileId = entity.RecruitmentCampaignFileId };
                var returnDto   = _mapper.Map <FileDto>(entity);
                return(CreatedAtAction(nameof(RecruitmentFile), routeValues, returnDto));
            }
            return(BadRequest(result.Errors));
        }
        public async Task <ActionResult <FileDto> > StudentEditVerifyFile([FromRoute] string fileId, [FromBody] FileEditDto dto)
        {
            FileEditDtoValidator validator = new FileEditDtoValidator();
            ValidationResult     result    = await validator.ValidateAsync(dto);

            if (result.IsValid)
            {
                var userId = User.Claims
                             .Single(p => p.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier").Value;
                var student = await _dbContext.Students
                              .Include(x => x.StudentVerify)
                              .Include(x => x.StudentVerify.StudentVerifyFiles)
                              .SingleOrDefaultAsync(x => x.ApplicationUserId == userId);

                if (student.StudentConfirmed)
                {
                    return(Problem(title: "禁止修改", detail: "在校生已驗證", statusCode: 403));
                }
                var entity = student.StudentVerify.StudentVerifyFiles
                             .SingleOrDefault(x => x.StudentVerifyFileId == fileId);
                if (entity == null)
                {
                    return(NotFound());
                }
                var updateEntity = _mapper.Map(dto, entity);
                _dbContext.StudentVerifyFiles.Update(updateEntity);
                await _dbContext.SaveChangesAsync();

                var returnDto   = _mapper.Map <FileDto>(updateEntity);
                var routeValues = new { fileId = returnDto.Id };
                return(CreatedAtAction(nameof(StudentVerifyFile), routeValues, returnDto));
            }
            return(BadRequest(result.Errors));
        }