@Override
public Response<Paging<Requirement>> findByParams(
BaseUser user,
Integer qualifyStatus,
Integer status,
String reqName,
String startAt,
String endAt,
Integer pageNo,
Integer size) {
Response<Paging<Requirement>> result = new Response<Paging<Requirement>>();
// 验证用户是否已登入
if (user == null) {
log.error("create requirement solution, user must login.");
result.setError("user.not.login");
return result;
}
// 获取用户对应的供应商信息
Response<Company> companyRes = companyService.findCompanyByUserId(user.getId());
if (!companyRes.isSuccess()) {
log.error("query company failed, error code={}", companyRes.getError());
result.setError(companyRes.getError());
return result;
}
try {
Map<String, Object> params = Maps.newHashMap();
params.put("name", Strings.isNullOrEmpty(reqName) ? null : reqName);
params.put("qualifyStatus", qualifyStatus);
params.put("status", status);
params.put("startAt", startAt);
params.put("endAt", endAt);
PageInfo pageInfo = new PageInfo(pageNo, Objects.firstNonNull(size, 10));
params.putAll(pageInfo.toMap());
result.setResult(requirementDao.findBySupplier(companyRes.getResult().getId(), params));
} catch (Exception e) {
log.error(
"find requirement solutions failed, supplierId={}, error code={}",
companyRes.getResult().getId(),
Throwables.getStackTraceAsString(e));
result.setError("solution.find.failed");
}
return result;
}
@Override
public LoginDTO getUserSession(String code, String password) {
LoginDTO userFinal = null;
try {
User user = userService.findByCodeAndPassword(code, password);
Teacher testTeacher = teacherService.findByUser(user);
if (testTeacher != null) {
userFinal =
new LoginDTO(
user.getId(),
code,
testTeacher.getName(),
testTeacher.getLastName(),
UserType.TEACHER);
}
if (testTeacher == null) {
Attendant testAttendant = attendantService.findByUser(user);
if (testAttendant == null) {
Company testCompany = companyService.findById(user.getId());
userFinal = new LoginDTO(user.getId(), code, testCompany.getName(), "", UserType.COMPANY);
} else {
userFinal =
new LoginDTO(
user.getId(),
code,
testAttendant.getName(),
testAttendant.getLastName(),
UserType.ATTENDANT);
}
}
} catch (Exception e) {
System.out.println("User + Password don't match.");
}
return userFinal;
}
public Offer postOffer(
String title, String description, String location, String url, Integer companyId) {
Validate.isTrue(
companyService.exists(companyId), "Company with Id=" + companyId + " does not exist");
Offer offer = new Offer();
offer.setTitle(normalize(title));
offer.setDescription(normalize(description));
offer.setLocation(normalize(location));
offer.setUrl(normalize(url));
offer.setPublicationDate(new Date());
offer.setUpdated(new Date());
offer.setCompanyId(companyId);
try {
offerDAO.create(offer);
return offer;
} catch (DataIntegrityViolationException e) {
throw new IllegalArgumentException("Cannot create offer with given parameters", e);
}
}
void validateCompanies(List<VacancyTemplate> vacancyTemplates) {
List<Company> companies = new ArrayList<>();
Set<String> companyCaptions = new HashSet<String>();
vacancyTemplates.forEach(
vacancyTemplate -> companyCaptions.add(vacancyTemplate.getCompanyCaption()));
companyCaptions.forEach(
s -> {
Company company = companyService.findByCaption(s);
if (company == null) {
company = new Company();
company.setCaption(s);
BeanPropertyBindingResult result = new BeanPropertyBindingResult(company, s);
ValidationUtils.invokeValidator(validator, company, result);
if (result.hasErrors()) {
List<ObjectError> errors = result.getAllErrors();
StringBuilder builder = new StringBuilder();
builder.append(
String.format(
"Validate company '%s' . No of validation errors: %s", s, errors.size()));
errors.forEach(
objectError -> {
builder.append("\n");
builder.append(objectError.getDefaultMessage());
});
log.error(builder.toString());
} else {
companies.add(company);
}
}
});
saveAllCompanies(companies);
}
@Override
public Response<Boolean> createSolution(RequirementSolution solution, BaseUser user) {
Response<Boolean> result = new Response<Boolean>();
// 验证用户是否已登入
if (user == null) {
log.error("create requirement solution, user must login.");
result.setError("user.not.login");
return result;
}
// 获取用户对应的供应商信息
Response<Company> companyRes = companyService.findCompanyByUserId(user.getId());
if (!companyRes.isSuccess()) {
log.error("query company failed, error code={}", companyRes.getError());
result.setError(companyRes.getError());
return result;
}
// 判断供应商是否已经对于需求进行了承诺
Response<RequirementSolution> existRes =
existSolution(solution.getRequirementId(), companyRes.getResult().getId());
if (!existRes.isSuccess()) {
log.error("check solution existed failed, error code={}", existRes.getError());
result.setError(existRes.getError());
return result;
}
if (existRes.getResult() != null) {
log.error("supplier have send solution,can't send again.");
result.setError("solution.existed.error");
return result;
}
// 需要保证该方案处于3:方案交互 or 4:方案综投（采购商才能够创建方案）
RequirementStatus[] statuses = {RequirementStatus.SOL_INTERACTIVE, RequirementStatus.SOL_END};
Response<Boolean> statusRes = checkRequirementStatus(solution.getRequirementId(), statuses);
if (!statusRes.isSuccess()) {
log.error("check requirement status failed, error code={}", statusRes.getError());
result.setError(statusRes.getError());
return result;
}
// 无法创建方案
if (!statusRes.getResult()) {
log.error("requirement status can't allow suppler send solution.");
result.setError("solution.status.stop");
return result;
}
try {
// 获取需求方案信息
Requirement requirement = requirementDao.findById(solution.getRequirementId());
solution.setRequirementName(requirement.getName());
solution.setSupplierId(companyRes.getResult().getId());
solution.setSupplierName(companyRes.getResult().getCorporation());
solution.setUserId(user.getId());
// 默认的T评分
solution.setTechnology(TECHNOLOGY);
// 写入方案承诺后需求方案的状态
if (solution.getNotAccept() == null) {
// 全部承诺
solution.setStatus(RequirementSolution.Status.ALL_ACCEPT.value());
} else {
solution.setStatus(RequirementSolution.Status.LITTLE_ACCEPT.value());
}
result.setResult(requirementSolutionDao.create(solution) != null);
} catch (Exception e) {
log.error(
"create requirement solution failed, error code={}", Throwables.getStackTraceAsString(e));
result.setError("solution.create.failed");
}
return result;
}
@Override
public Response<Boolean> checkSupplierInfo(Long requirementId, BaseUser user) {
Response<Boolean> result = new Response<Boolean>();
Requirement requirement = requirementDao.findById(requirementId);
// 写入供应商信用等级信息
Response<SupplierCreditQualify> creditRes =
supplierCreditQualifyService.findCreditQualifyByUserId(user.getId());
if (!creditRes.isSuccess()) {
log.error("find supplier credit qualify info failed, error code={}", creditRes.getError());
result.setError(creditRes.getError());
return result;
}
if (!creditRes.getResult().isCreditQualified()) {
log.error("supplier credit is not allow to do.");
result.setError("supplier.credit.failed");
return result;
}
// 获取公司信息
Response<Company> companyRes = companyService.findCompanyByUserId(user.getId());
if (!companyRes.isSuccess()) {
result.setError(companyRes.getError());
return result;
}
// 获取后台三级类目信息
List<BackendJSON> categoryList =
JSON_MAPPER.fromJson(
requirement.getSeriesIds(),
JSON_MAPPER.createCollectionType(List.class, BackendJSON.class));
List<Long> categoryIds = Lists.newArrayList();
for (BackendJSON backendJSON : categoryList) {
categoryIds.add(backendJSON.getBcId());
}
// 获取供应商资质验证信息
Response<Integer> qualifyRes =
supplierResourceMaterialService.getInfoInBcIds(companyRes.getResult().getId(), categoryIds);
if (!qualifyRes.isSuccess()) {
log.error(
"find user qualify failed, userId={}, error code={}",
user.getId(),
qualifyRes.getError());
result.setError(qualifyRes.getError());
return result;
}
// 资质是否全部验证通过
if (!Objects.equal(
SupplierResourceMaterialInfo.Status.from(qualifyRes.getResult()),
SupplierResourceMaterialInfo.Status.QUALIFIED)) {
log.error("supplier resource is not allow to do.");
result.setError("supplier.resource.failed");
return result;
}
result.setResult(true);
return result;
}
@Override
public Response<Boolean> signSecrecy(Long requirementId, Integer signType, BaseUser user) {
Response<Boolean> result = new Response<Boolean>();
if (requirementId == null) {
log.error("find requirement solution need requirementId");
result.setError("solution.requirementId.null");
return result;
}
// 验证用户是否已登入
if (user == null) {
log.error("create requirement solution, user must login.");
result.setError("user.not.login");
return result;
}
try {
// 是否是供应商
if (Objects.equal(user.getType(), User.Type.SUPPLIER.value())) {
// 验证供应商信息是否完整（不完整无法显示需求详情）
Response<Boolean> checkRes = companyService.isComplete(user.getId());
if (!checkRes.isSuccess()) {
log.error("check user complete info failed, error code={}", checkRes.getError());
result.setError(checkRes.getError());
return result;
}
if (!checkRes.getResult()) {
log.error("company info is not complete.");
result.setError("requirement.company.noComplete");
return result;
}
} else {
// 采购商直接跳转
result.setResult(true);
return result;
}
// 查询供应商保密协议是否已签订
if (signType == null) {
// 查询登录的供应商是否已经淘汰
Response<User> supplier = accountService.findUserById(user.getId());
if (Objects.equal(supplier.getResult().getStep(), User.Step.DIE_OUT.value())) {
log.error("supplier is die_out.");
result.setError("supplier.is.dieout");
return result;
}
// 查询登录供应商是否绩效的质量得分在60下
Response<SupplierTQRDCInfo> suTQRDinfo =
companyService.findSupplierLastTQRDCInfoByUserId(user.getId());
if (suTQRDinfo.getResult().getQualityScore() != null) {
if (suTQRDinfo.getResult().getQualityScore() < 60) {
log.error("supplier quality score less.");
result.setError("supplier.quality.less");
return result;
}
}
// 在淘汰供应商物料明细表中的也不让查看
Response<Company> comtemp = companyService.findCompanyByUserId(user.getId());
if (!comtemp.isSuccess()) {
log.error("query company failed, error code={}", comtemp.getError());
result.setError(comtemp.getError());
return result;
}
if (comtemp.getResult().getSupplierCode() != null
|| comtemp.getResult().getSupplierCode() != "") {
List<SupplierModuleDetail> templ =
supplierModuleDetailService
.findBySupplierCode(comtemp.getResult().getSupplierCode())
.getResult();
if (templ.size() > 0) {
log.error("supplier module Detail have.");
result.setError("supplier.module.detail.have.some");
return result;
}
}
RequirementSolution solution =
requirementSolutionDao.findByUserId(requirementId, user.getId());
result.setResult(solution != null);
} else {
RequirementSolution solution = new RequirementSolution();
// 获取用户对应的供应商信息
Response<Company> companyRes = companyService.findCompanyByUserId(user.getId());
if (!companyRes.isSuccess()) {
log.error("query company failed, error code={}", companyRes.getError());
result.setError(companyRes.getError());
return result;
}
// 判断供应商是否已经签订过协议
Response<RequirementSolution> existRes =
existSolution(requirementId, companyRes.getResult().getId());
if (!existRes.isSuccess()) {
log.error("check solution existed failed, error code={}", existRes.getError());
result.setError(existRes.getError());
return result;
}
if (existRes.getResult() != null) {
log.error("supplier have send solution,can't send again.");
result.setError("solution.sign.failed");
return result;
}
// 获取需求信息
Requirement requirement = requirementDao.findById(requirementId);
solution.setRequirementId(requirementId);
solution.setRequirementName(requirement.getName());
solution.setSupplierId(companyRes.getResult().getId());
solution.setSupplierName(companyRes.getResult().getCorporation());
solution.setUserId(user.getId());
// 默认的T评分
solution.setTechnology(TECHNOLOGY);
// 签订保证协议
solution.setStatus(RequirementSolution.Status.SIGN_CONF.value());
if (requirementSolutionDao.create(solution) != null) {
// 增加供应商的方案统计数据
SupplierSolutionCount supplierSolutionCount = new SupplierSolutionCount();
supplierSolutionCount.setUserId(user.getId());
supplierSolutionCount.setUserName(user.getName());
supplierSolutionCount.setStatusCounts(ImmutableMap.of(requirement.getStatus(), 1));
solutionCountService.setSupCount(supplierSolutionCount);
// 供应商交互方案统计
solutionCountService.setSolCountInfo(user.getId(), SolutionCountType.MUTUAL_SOL, 1);
result.setResult(true);
} else {
result.setError("solution.sign.failed");
}
}
} catch (Exception e) {
log.error(
"find user sign requirement solution failed, requirementId={}, userId={}, error code={}",
requirementId,
user.getId(),
Throwables.getStackTraceAsString(e));
result.setError("solution.find.failed");
}
return result;
}
List<Vacancy> validateVacancies(List<VacancyTemplate> vacancyTemplates) {
Set<String> vacancyURLs = new HashSet<>();
List<Vacancy> vacancies = new ArrayList<>();
for (VacancyTemplate vt : vacancyTemplates) {
Company company = companyService.findByCaption(vt.getCompanyCaption());
if (company == null)
log.error(
"Job missing: '{}'. Reason: company '{}' not found",
vt.getVacancyCaption(),
vt.getCompanyCaption());
else if (!vacancyURLs.contains(vt.getVacancyUrl())) {
String pathSegment;
try {
pathSegment =
UriUtils.encodePathSegment(vt.getVacancyUrl(), WebUtils.DEFAULT_CHARACTER_ENCODING);
} catch (UnsupportedEncodingException uee) {
log.error(uee.toString());
continue;
}
vacancyURLs.add(pathSegment);
Vacancy vacancy = new Vacancy();
vacancy.setId(pathSegment);
vacancy.setCaption(vt.getVacancyCaption());
vacancy.setUrl(vt.getVacancyUrl());
vacancy.setPriceMax(vt.getPriceMax());
vacancy.setPriceMin(vt.getPriceMin());
vacancy.setRegistrationDate(vt.getRegistrationDate());
vacancy.setCurrency(currencyService.findByCaption(vt.getCurrencyCaption()));
vacancy.setSite(vt.getSite());
vacancy.setCity(vt.getCity());
vacancy.setCompany(company);
BeanPropertyBindingResult result =
new BeanPropertyBindingResult(vacancy, vacancy.getCaption());
ValidationUtils.invokeValidator(validator, vacancy, result);
if (result.hasErrors()) {
List<ObjectError> errors = result.getAllErrors();
StringBuilder builder = new StringBuilder();
builder.append(
String.format(
"Validate vacancy '%s' . No of validation errors: %s",
vacancy.getCaption(), errors.size()));
errors.forEach(
objectError -> {
builder.append("\n");
builder.append(objectError.getDefaultMessage());
});
log.error(builder.toString());
} else {
vacancies.add(vacancy);
}
}
}
return vacancies;
}
@Transactional
void saveAllCompanies(List<Company> companies) {
companyService.save(companies);
}
