Java tutorial
/** * Copyright (C) 2015 Born Informatik AG (www.born.ch) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.wte4j.ui.server.services; import java.io.IOException; import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; import org.wte4j.ExpressionError; import org.wte4j.InvalidTemplateException; import org.wte4j.LockingException; import org.wte4j.MappingDetail; import org.wte4j.Template; import org.wte4j.TemplateBuilder; import org.wte4j.TemplateEngine; import org.wte4j.TemplateExistException; import org.wte4j.TemplateFile; import org.wte4j.TemplateRepository; import org.wte4j.WteException; import org.wte4j.WteModelService; import org.wte4j.ui.shared.InvalidTemplateServiceException; import org.wte4j.ui.shared.MappingDto; import org.wte4j.ui.shared.ModelElementDto; import org.wte4j.ui.shared.TemplateDto; import org.wte4j.ui.shared.TemplateService; import org.wte4j.ui.shared.TemplateServiceException; @Service public class TemplateServiceImpl implements TemplateService { private final Logger logger = LoggerFactory.getLogger(getClass()); @Autowired private ServiceContext serviceContext; @Autowired @Qualifier("wte4j-admin") private MessageFactory messageFactory; @Autowired private TemplateEngine templateEngine; @Autowired private TemplateRepository templateRepository; @Autowired private WteModelService modelService; @Override public List<TemplateDto> getTemplates() { List<Template<Object>> templates = templateRepository.queryTemplates().list(); List<TemplateDto> templateDtos = new ArrayList<TemplateDto>(); for (Template<Object> template : templates) { TemplateDto templateDto = DtoFactory.createTemplateDto(template); templateDtos.add(templateDto); } return templateDtos; } @Override public TemplateDto lockTemplate(TemplateDto templateDto) { try { Template<?> template = lookup(templateDto); template = templateRepository.lockForEdit(template, serviceContext.getUser()); return DtoFactory.createTemplateDto(template); } catch (WteException e) { throw createServiceException(e, templateDto); } } @Override public TemplateDto unlockTemplate(TemplateDto templateDto) { try { Template<?> template = lookup(templateDto); template = templateRepository.unlock(template); return DtoFactory.createTemplateDto(template); } catch (WteException e) { throw createServiceException(e, templateDto); } } @Override public void deleteTemplate(TemplateDto templateDto) { try { Template<?> template = lookup(templateDto); templateRepository.delete(template); } catch (WteException e) { throw createServiceException(e, templateDto); } } @Override public List<ModelElementDto> listModelElements(String inputType, Map<String, String> properties) throws TemplateServiceException { try { Class<?> inputClass = Class.forName(inputType); Map<String, Class<?>> modelElements = modelService.listModelElements(inputClass, properties); List<ModelElementDto> dtos = new ArrayList<>(modelElements.size()); for (Map.Entry<String, Class<?>> entry : modelElements.entrySet()) { ModelElementDto dto = new ModelElementDto(); dto.setName(entry.getKey()); dto.setType(entry.getValue().getName()); dtos.add(dto); } return dtos; } catch (ClassNotFoundException e) { throw createServiceException(MessageKey.TEMPLATE_CLASS_NOT_FOUND, e); } catch (RuntimeException e) { throw createServiceException(MessageKey.INTERNAL_SERVER_ERROR, e); } } @Override public TemplateDto saveTemplateData(TemplateDto templateDto, String uploadedTemplate) throws TemplateServiceException { Path path = Paths.get(uploadedTemplate); if (!Files.exists(path)) { throw createServiceException(MessageKey.TEMPLATE_NOT_FOUND); } Template<?> template = lookup(templateDto); try (InputStream in = Files.newInputStream(path)) { template.update(in, serviceContext.getUser()); copyMappingData(template.getContentMapping(), templateDto.getMapping()); template.validate(); template = templateRepository.persist(template); return DtoFactory.createTemplateDto(template); } catch (IOException e) { throw createServiceException(MessageKey.INTERNAL_SERVER_ERROR, e); } catch (WteException e) { throw createServiceException(e, templateDto); } } @Override public TemplateDto createTemplate(TemplateDto newTemplate, String templateFile) { try { Class<?> clazz = Class.forName(newTemplate.getInputType()); Map<String, MappingDetail> mappingData = new HashMap<String, MappingDetail>(); copyMappingData(mappingData, newTemplate.getMapping()); TemplateBuilder<?> templateBuilder = templateEngine.getTemplateBuilder(clazz); templateBuilder.setAuthor(serviceContext.getUser()).setDocumentName(newTemplate.getDocumentName()) .setLanguage(newTemplate.getLanguage()).setMappingData(mappingData); if (StringUtils.isNotEmpty(templateFile)) { Path filePath = Paths.get(templateFile); if (!Files.exists(filePath)) { throw createServiceException(MessageKey.TEMPLATE_NOT_FOUND); } templateBuilder.setTemplateFile(filePath); } Template<?> template = templateBuilder.build(); template.validate(); template = templateRepository.persist(template); return DtoFactory.createTemplateDto(template); } catch (ClassNotFoundException e) { throw createServiceException(MessageKey.TEMPLATE_CLASS_NOT_FOUND, e); } catch (WteException e) { throw createServiceException(e, newTemplate); } } @Override public List<String> listUniqueContentIds(String pathToFile) throws TemplateServiceException { Path filePath = Paths.get(pathToFile); if (!Files.exists(filePath)) { throw createServiceException(MessageKey.TEMPLATE_NOT_FOUND); } try { TemplateFile templateFile = templateEngine.asTemplateFile(filePath); List<String> contentIds = templateFile.listContentIds(); Set<String> uniqueContentIds = new HashSet<String>(contentIds); contentIds.clear(); contentIds.addAll(uniqueContentIds); return contentIds; } catch (IOException e) { throw createServiceException(MessageKey.INTERNAL_SERVER_ERROR, e); } catch (WteException e) { logger.debug("error on parsing file {}", pathToFile, e); throw createServiceException(MessageKey.UPLOADED_FILE_NOT_VALID, e); } } private static void copyMappingData(Map<String, MappingDetail> target, List<MappingDto> source) { target.clear(); for (MappingDto dto : source) { if (StringUtils.isNotBlank(dto.getModelKey()) || StringUtils.isNotBlank(dto.getFormatterDefinition())) { MappingDetail mappingDetail = new MappingDetail(); mappingDetail.setModelKey(dto.getModelKey()); mappingDetail.setFormatterDefinition(dto.getFormatterDefinition()); target.put(dto.getConentControlKey(), mappingDetail); } } } Template<?> lookup(TemplateDto dto) { Template<?> template = templateRepository.getTemplate(dto.getDocumentName(), dto.getLanguage()); if (template == null) { throw createServiceException(MessageKey.TEMPLATE_NOT_FOUND); } return template; } TemplateServiceException createServiceException(WteException exception, TemplateDto source) { if (exception instanceof InvalidTemplateException) { return createAndThrowInvalidTemplateServiceException((InvalidTemplateException) exception); } else if (exception instanceof LockingException) { return createServiceException(MessageKey.LOCKED_TEMPLATE, exception); } else if (exception instanceof TemplateExistException) { return createServiceException(MessageKey.TEMPLATE_EXISTS, exception); } else { logger.error("error on processing template {}", source, exception); return createServiceException(MessageKey.INTERNAL_SERVER_ERROR, exception); } } TemplateServiceException createServiceException(MessageKey key, Throwable cause) { String message = messageFactory.createMessage(key.getValue()); return new TemplateServiceException(message, cause); } TemplateServiceException createServiceException(MessageKey key) { String message = messageFactory.createMessage(key.getValue()); return new TemplateServiceException(message); } InvalidTemplateServiceException createAndThrowInvalidTemplateServiceException(InvalidTemplateException e) { String message = messageFactory.createMessage(MessageKey.UPLOADED_FILE_NOT_VALID.getValue()); List<String> details = new ArrayList<String>(); for (Map.Entry<String, ExpressionError> entry : e.getErrors().entrySet()) { String detailMessage = messageFactory.createMessage("wte4j.message." + entry.getValue().name(), entry.getKey()); details.add(detailMessage); } return new InvalidTemplateServiceException(message, details); } }