//设置package包名称以及导入依赖的类
package com.piotrglazar.receiptlottery.utils

import org.springframework.beans.factory.annotation.{Autowired, Value}
import org.springframework.stereotype.Component

import scala.concurrent.{ExecutionContext, Future}
import scalaj.http.Http

@Component
class ScalajHttpAdapter @Autowired()(@Value("${http.timeouts:2000}") private val timeouts: Int) extends HttpAdapter {

  override def request(url: String, params: Map[String, String]): String =
    Http(url)
      .params(params)
      .timeout(timeouts, timeouts)
      .asString
      .body

  override def asyncRequest(url: String, params: Map[String, String])
                           (implicit executionContext: ExecutionContext): Future[String] =
    Future(request(url, params))
} 

//设置package包名称以及导入依赖的类
package fr.sysf.sample.service


import java.net.HttpURLConnection
import javax.validation.Valid

import fr.sysf.sample.domain.Customer
import io.swagger.annotations.{Api, ApiOperation, ApiResponse, ApiResponses}
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.http.{HttpStatus, MediaType, ResponseEntity}
import org.springframework.web.bind.annotation._


@Api(value = "Customers service", consumes = "application/json;charset=UTF-8", produces = "application/json;charset=UTF-8")
@RestController
@RequestMapping(Array("/customers"))
class CustomerController {

  @Autowired
  private val customerRepository: CustomerRepository = null

  @ApiOperation(value = "Put_Customers", notes = "method to create new Customer or update customer")
  @ApiResponses(value = Array(
    new ApiResponse(code = HttpURLConnection.HTTP_BAD_REQUEST, message = "Bad Request"),
    new ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = "Not found"),
    new ApiResponse(code = HttpURLConnection.HTTP_ACCEPTED, response = classOf[Customer], message = "Success PUT")
  ))
  @RequestMapping(
    value = Array("/"),
    method = Array(RequestMethod.PUT, RequestMethod.POST, RequestMethod.PATCH),
    produces = Array(MediaType.APPLICATION_JSON_UTF8_VALUE))
  def setCustomer(
                   @Valid @RequestBody customer: Customer
                 ): ResponseEntity[Customer] = {

    val customerExisted = customerRepository.findByEmail(customer.email)
    if (customerExisted != null) {
      customer.id = customerExisted.id
      customer.version = customerExisted.version
    }
    val customerSaved = customerRepository.save(customer)

    new ResponseEntity[Customer](customerSaved, HttpStatus.ACCEPTED)
  }

} 

//设置package包名称以及导入依赖的类
package fr.sysf.sample

import java.time.LocalDate

import fr.sysf.sample.domain.Customer
import fr.sysf.sample.service.CustomerRepository
import org.assertj.core.api.Assertions
import org.assertj.core.api.Assertions.assertThat
import org.junit.Test
import org.junit.runner.RunWith
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner


@RunWith(classOf[SpringJUnit4ClassRunner])
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT, classes = Array(classOf[ApplicationConfig]))
//@ContextConfiguration(classes = Array(classOf[ApplicationConfig]))
class CustomerDataTest {

  @Autowired
  private val customerRepository: CustomerRepository = null

  @Test
  def getHello {

    val customer = new Customer()
    customer.firstName = "Anna"
    customer.lastName = "Blum"
    customer.birthDate = LocalDate.of(1965, 2, 7)

    var request = customerRepository.save(customer)

    // getAll before insert
    assertThat(request).isNotNull
    assertThat(request.createdDate).isNotNull
    assertThat(request.updatedDate).isEqualTo(request.createdDate)
    Assertions.assertThat(request.version).isEqualTo(0l)

    request.city = "Paris"
    request = customerRepository.save(request)

    assertThat(request).isNotNull
    Assertions.assertThat(request.createdDate).isNotNull
    Assertions.assertThat(request.city).isEqualTo("Paris")
    Assertions.assertThat(request.version).isEqualTo(1l)


  }
} 

//设置package包名称以及导入依赖的类
package fr.sysf.sample

import org.junit.runner.RunWith
import org.junit.{Ignore, Test}
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment
import org.springframework.boot.test.web.client.TestRestTemplate
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner


@RunWith(classOf[SpringJUnit4ClassRunner])
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT, classes = Array(classOf[ApplicationConfig]))
class ApiRestTest {

  @Autowired
  private val restTemplate: TestRestTemplate = null


  // todo: to complete
  @Ignore
  @Test
  def should_put_customer_when_it_does_not_exits {

  }
} 

//设置package包名称以及导入依赖的类
package com.piotrglazar.receiptlottery.extension

import akka.actor.ActorSystem
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationContext
import org.springframework.context.annotation.{Bean, Configuration}

import scala.concurrent.ExecutionContext

@Configuration
class AppConfiguration {

  @Autowired
  var applicationContext: ApplicationContext = _

  @Bean
  def actorSystem(): ActorSystem = {
    val sys = ActorSystem()
    SpringExtension.provider.get(sys).initialize(applicationContext)
    sys
  }

  @Bean
  def executionContext(actorSystem: ActorSystem): ExecutionContext =
    actorSystem.dispatcher
} 

//设置package包名称以及导入依赖的类
package com.piotrglazar.receiptlottery.core

import com.piotrglazar.receiptlottery.Token
import com.piotrglazar.receiptlottery.utils.HttpAdapter
import org.htmlcleaner.{HtmlCleaner, TagNode}
import org.springframework.beans.factory.annotation.{Autowired, Value}
import org.springframework.stereotype.Component

import scala.concurrent.{ExecutionContext, Future}

@Component
class ResultFetcher @Autowired()(@Value("${results.page}") private val pageAddress: String, private val httpAdapter: HttpAdapter,
                                 implicit private val executionContext: ExecutionContext) {

  def hasResult(token: Token): Future[Boolean] = {
    val rawContentFuture = httpAdapter.asyncRequest(pageAddress, Map("code" -> token.value))
    rawContentFuture.map { rawContent =>
      val cleanContent: TagNode = new HtmlCleaner().clean(rawContent)

      !getResultTables(cleanContent)
        .flatMap(getResultTableBody)
        .flatMap(getResultTableRows)
        .isEmpty
    }
  }

  private def getResultTables(page: TagNode): Array[TagNode] =
    page.getElementsByAttValue("class", "results-table", true, true)

  private def getResultTableBody(table: TagNode): Array[TagNode] =
    table.getElementsByName("tbody", true)

  private def getResultTableRows(tableBody: TagNode): Array[TagNode] =
    tableBody.getElementsByName("tr", true)
} 

//设置package包名称以及导入依赖的类
package com.piotrglazar.receiptlottery.core

import akka.actor.Actor
import com.piotrglazar.receiptlottery.{Token, VerifiedToken}
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.Scope
import org.springframework.stereotype.Component

@Component("workingActor")
@Scope("prototype")
class WorkingActor @Autowired()(private val resultFetcher: ResultFetcher) extends Actor {

  implicit private val executionContext = context.system.dispatcher

  override def receive: Receive = {
    case token: Token =>
      val requester = sender()
      val resultFuture = resultFetcher.hasResult(token)
      resultFuture.onSuccess { case result => requester ! VerifiedToken(token, result) }
  }
} 

//设置package包名称以及导入依赖的类
package com.piotrglazar.receiptlottery.core

import com.piotrglazar.receiptlottery.Token
import org.springframework.beans.factory.annotation.{Value, Autowired}
import org.springframework.stereotype.Component
import rx.lang.scala.Observable

import scala.io.Source
import scala.util.{Failure, Success, Try}

@Component
class TokenReader @Autowired()(@Value("${token.file}") private val path: String) {

  def readTokens(): Observable[Token] = {
    readContent() match {
      case Success(items) => Observable.from(items)
      case Failure(e) => Observable.error(e)
    }
  }

  private def readContent(): Try[List[Token]] =
    Try {
      Source.fromInputStream(getClass.getResourceAsStream(path))
        .getLines()
        .filter(!_.isEmpty)
        .map(Token)
        .toList
    }
} 

//设置package包名称以及导入依赖的类
package com.piotrglazar.receiptlottery

import akka.actor.ActorSystem
import org.springframework.beans.factory.annotation.{Qualifier, Autowired}
import org.springframework.test.context.ContextConfiguration

@ContextConfiguration(classes = Array[Class[_]](classOf[ReceiptLottery]))
class ReceiptLotteryTest extends BaseContextTest  {

  override def beforeAll(): Unit = {
    System.setProperty("token.file", "/testTokens.txt")
    System.setProperty("results.page", "https://loteriaparagonowa.gov.pl/wyniki")
    super.beforeAll()
  }

  @Autowired
  @Qualifier("actorSystem")
  var actorSystem: ActorSystem = _

  "ReceiptLottery" should "use actors to verify tokens" in {
    // given
    // context loaded

    // when
    new ReceiptLottery().runActors_=(actorSystem)

    // then
    System.setProperty("token.file", "")
  }
} 

//设置package包名称以及导入依赖的类
package com.kemalates.demo02

import com.kemalates.demo02.service.MyService
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.{CommandLineRunner, SpringApplication}
import org.springframework.boot.autoconfigure.SpringBootApplication


@SpringBootApplication
class MyApp extends CommandLineRunner {

  @Autowired
  val myService: MyService = null

  override def run(args: String*) = {
    myService.sayHello()
  }
}

object MyApp extends App {
  SpringApplication run classOf[MyApp]
} 

//设置package包名称以及导入依赖的类
package k8sslbnginxing.actuator
import akka.actor.ActorSystem
import com.google.common.base.Stopwatch
import io.fabric8.kubernetes.client.KubernetesClient
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.actuate.health.{Health, HealthIndicator}
import org.springframework.context.annotation.{Bean, Configuration}

@Configuration
class ActuatorConfig {

  @Autowired
  private var actorSystem: ActorSystem = _

  @Autowired
  private var kubernetesClient: KubernetesClient = _

  @Bean
  def kubernetesHealthIndicator: HealthIndicator = () => {
    try {
      val watch = Stopwatch.createStarted()
      kubernetesClient.services().inNamespace("default").withName("kubernetes").get()
      watch.stop()
      Health.up()
          .withDetail("get", "GET Service [email protected] in " + watch.toString)
          .build()
    } catch {
      case e: Exception =>
        Health.down(e).build()
    }
  }
} 

//设置package包名称以及导入依赖的类
package org.pdfextractor.algorithm.finder.it

import org.pdfextractor.algorithm.finder.AbstractFinderTest
import org.slf4j.{Logger, LoggerFactory}
import org.springframework.beans.factory.annotation.Autowired
import org.pdfextractor.algorithm.phrase.PhraseTypesStore

class ItalianInvoiceIDFinderTest extends AbstractFinderTest {

  val log: Logger = LoggerFactory.getLogger(classOf[PhraseTypesStore])

  @Autowired var italianInvoiceIDFinder: ItalianInvoiceIDFinder = _

  "Italian invoice ID finder" should "parse" in {
    val idText = "Numero fattura: 3816442625428252-20"
    val parsed = italianInvoiceIDFinder.parseValue(idText).asInstanceOf[String]
    assert("3816442625428252-20" == parsed)
  }

  "Italian invoice ID finder" should "find from start" in {
    assert(italianInvoiceIDFinder.searchPattern.get.findFirstIn("Fattura n.6 del 23.02.2016").nonEmpty)
  }

  "Italian invoice ID finder" should "find from line" in {
    assert(italianInvoiceIDFinder.getValuePattern.findFirstIn("Fattura n.6 del 23.02.2016").nonEmpty)
    assert("Fattura n.6" == italianInvoiceIDFinder.getValuePattern.findFirstIn("Fattura n.6 del 23.02.2016").get)
    assert("Fattura n.654343-3s" == italianInvoiceIDFinder.getValuePattern.findFirstIn("Fattura n.654343-3s del 23.02.2016").get)
    assert("654343-3s" == italianInvoiceIDFinder.StartR.replaceFirstIn("Fattura n.654343-3s", ""))
  }

} 

//设置package包名称以及导入依赖的类
package org.pdfextractor.algorithm.finder.et

import org.pdfextractor.algorithm.candidate.Candidate
import org.pdfextractor.algorithm.finder.{AbstractFinderTest, AbstractInvoiceFileReader}
import org.pdfextractor.algorithm.io._
import org.slf4j.{Logger, LoggerFactory}
import org.springframework.beans.factory.annotation.Autowired
import org.pdfextractor.algorithm.parser.{PDFFileParser, ParseResult, Phrase}
import org.pdfextractor.algorithm.phrase.PhraseTypesStore

import scala.collection.LinearSeq

class EstonianInvoiceIDFinderTest extends AbstractFinderTest {

  val log: Logger = LoggerFactory.getLogger(classOf[PhraseTypesStore])

  @Autowired var estonianInvoiceIDFinder: EstonianInvoiceIDFinder = _

  "Estonian invoice ID finder" should "find from phrase" in {
    val invoiceAsString = getStringFromFile("EestiEnergia.txt")
    val phrase: Phrase = new Phrase(1, 1, 1, 1, 1, invoiceAsString, false)
    val phrases: LinearSeq[Phrase] = LinearSeq(phrase)
    val parseResult: ParseResult = new ParseResult("", phrases)

    val candidates: Seq[Candidate] = estonianInvoiceIDFinder.findCandidates(parseResult)

    assert(candidates.nonEmpty)

    val foundValues: Seq[String] = candidates.map(_.getValue.asInstanceOf[String])

    assert(foundValues.head == "Arve nr 12345")
  }

  "Estonian invoice ID finder" should "find from real PDF" in {
    val inputStream = getInputStreamFromFile(AbstractInvoiceFileReader.Starman)
    val parseResult = PDFFileParser.parse(inputStream)
    val candidates = estonianInvoiceIDFinder.findCandidates(parseResult)

    assert(candidates.nonEmpty)
    assert(candidates.size == 1)

    val firstCandidate = candidates.head

    assert(Option(firstCandidate.value).isDefined)
    assert(Option(firstCandidate.x).isDefined)
    assert(Option(firstCandidate.y).isDefined)
    assert(firstCandidate.value == "Arve number A-123456")
    assert(330 == firstCandidate.x)
    assert(94 == firstCandidate.y)
  }

} 

//设置package包名称以及导入依赖的类
package org.pdfextractor.algorithm.finder.et

import org.pdfextractor.algorithm.candidate.{IsDouble, HasEuroSign}
import org.pdfextractor.algorithm.finder.{AbstractFinderTest, AbstractInvoiceFileReader}
import org.pdfextractor.algorithm.io._
import org.slf4j.{Logger, LoggerFactory}
import org.springframework.beans.factory.annotation.Autowired
import org.pdfextractor.algorithm.parser.PDFFileParser
import org.pdfextractor.algorithm.phrase.PhraseTypesStore
class EstonianTotalFinderTest extends AbstractFinderTest {

  val log: Logger = LoggerFactory.getLogger(classOf[PhraseTypesStore])

  @Autowired var estonianTotalFinder: EstonianTotalFinder = _

  "Estonian total finder" should "find from real invoice and have additional info present" in {
    val inputStream = getInputStreamFromFile(AbstractInvoiceFileReader.Starman)
    val parseResult = PDFFileParser.parse(inputStream)
    val candidates = estonianTotalFinder.findCandidates(parseResult)

    assert(candidates.nonEmpty)

    val firstCandidate = candidates.head

    assert(Option(firstCandidate.value).isDefined)
    assert(Option(firstCandidate.x).isDefined)
    assert(Option(firstCandidate.y).isDefined)
    assert(firstCandidate.value == 16.87d)
    assert(35 == firstCandidate.x)
    assert(414 == firstCandidate.y)
    assert(firstCandidate.properties.get(IsDouble).get.asInstanceOf[Boolean])
    assert(!firstCandidate.properties.get(HasEuroSign).get.asInstanceOf[Boolean])
  }

} 

//设置package包名称以及导入依赖的类
package org.pdfextractor.algorithm.finder.et

import org.pdfextractor.algorithm.candidate.Candidate
import org.pdfextractor.algorithm.finder.{AbstractFinderTest, AbstractInvoiceFileReader}
import org.pdfextractor.algorithm.io._
import org.slf4j.{Logger, LoggerFactory}
import org.springframework.beans.factory.annotation.Autowired
import org.pdfextractor.algorithm.parser.{PDFFileParser, ParseResult}
import org.pdfextractor.algorithm.phrase.PhraseTypesStore

import scala.collection.LinearSeq

class EstonianAccountNumberFinderTest extends AbstractFinderTest {

  val log: Logger = LoggerFactory.getLogger(classOf[PhraseTypesStore])

  @Autowired var estonianAccountNumberFinder: EstonianAccountNumberFinder = _

  "Estonian account finder" should "find from real PDF" in {
    val inputStream = getInputStreamFromFile(AbstractInvoiceFileReader.Starman)
    val parseResult = PDFFileParser.parse(inputStream)
    val candidates = estonianAccountNumberFinder.findCandidates(parseResult)
    assert(candidates.nonEmpty)
    assert(4 == candidates.size)
    val foundValues: Seq[String] = candidates.map(_.getValue.asInstanceOf[String])
    assert(foundValues.contains("EE882200001180000796"))
    assert(foundValues.contains("EE921010002046022001"))
    assert(foundValues.contains("EE103300332097940003"))
    assert(foundValues.contains("EE561700017000030979"))
  }

  "Estonian account finder" should "find from invoice as a string" in {
    val invoiceAsString = getStringFromFile("EestiEnergia.txt")
    val candidates: Seq[Candidate] = estonianAccountNumberFinder.findCandidates(new ParseResult(invoiceAsString, LinearSeq.empty))
    val foundValues: Seq[String] = candidates.map(_.getValue.asInstanceOf[String])
    assert(foundValues.nonEmpty)
    assert(foundValues.contains("EE232200001180005555"))
    assert(foundValues.contains("EE081010002059413005"))
    assert(foundValues.contains("EE703300332099000006"))
    assert(foundValues.contains("EE431700017000115797"))
  }

  "Estonian account finder" should "discard invalid accounts" in {
    val invoiceAsString = getStringFromFile("RiggedInvoice.txt")
    val candidates: Seq[Candidate] = estonianAccountNumberFinder.findCandidates(new ParseResult(invoiceAsString, LinearSeq.empty))
    assert(candidates.isEmpty)
  }

} 

//设置package包名称以及导入依赖的类
package ch.mibex.bamboo.shipit.settings

import ch.mibex.bamboo.shipit.Logging
import com.atlassian.activeobjects.external.ActiveObjects
import com.atlassian.bamboo.security.EncryptionService
import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport
import com.atlassian.sal.api.transaction.TransactionCallback
import net.java.ao.DBParam
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Component

@Component
class AdminSettingsDao @Autowired()(@ComponentImport ao: ActiveObjects,
                                    @ComponentImport encryptionService: EncryptionService) extends Logging {

  import AoAdminSettings._

  // we cannot use @Transactional annotations but instead have to wrap our DB code into executeInTransaction
  // because this annotation cannot be used on Bamboo remote agents
  def createOrUpdate(vendorName: String, vendorPassword: String): AoAdminSettings =
    executeInTransaction(() => {
      ao.find[AoAdminSettings, Integer](classOf[AoAdminSettings]).headOption match {
        case Some(credentials) =>
          credentials.setVendorUserName(vendorName)
          credentials.setVendorPassword(encryptionService.encrypt(vendorPassword))
          credentials.save()
          credentials
        case None =>
          ao.create[AoAdminSettings, Integer](
            classOf[AoAdminSettings],
            new DBParam(VENDOR_USERNAME_COLUMN, vendorName),
            new DBParam(VENDOR_PASSWORD_COLUMN, encryptionService.encrypt(vendorPassword))
          )
      }
    })

  def find(): Option[AoAdminSettings] =
    executeInTransaction(() => ao.find[AoAdminSettings, Integer](classOf[AoAdminSettings]).headOption)

  private def executeInTransaction[T](fun: () => T) =
    ao.executeInTransaction(new TransactionCallback[T]() {
      override def doInTransaction(): T = fun()
    })

} 

//设置package包名称以及导入依赖的类
package ch.mibex.bamboo.shipit.task

import java.util
import java.util.{Map => JMap}

import ch.mibex.bamboo.shipit.{Constants, Logging}
import com.atlassian.bamboo.chains.ChainResultsSummary
import com.atlassian.plugin.PluginAccessor
import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport
import com.atlassian.plugin.web.model.AbstractWebPanel
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Component

import scala.collection.JavaConverters._


@Component
class ShipItResultsLinkPanel @Autowired()(@ComponentImport pluginAccessor: PluginAccessor)
  extends AbstractWebPanel(pluginAccessor) with Logging {

  private val MpacLogoBase64Encoded =
    """<img src="data:image/jpeg;base64,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"/>"""

  // currently, there is no way to show a web panel on the environment of the deployment project,
  // see https://jira.atlassian.com/browse/BAM-13280
  override def getHtml(context: util.Map[String, AnyRef]): String = createMpacSubmissionLink(context)

  private def createMpacSubmissionLink(context: JMap[String, AnyRef]): String =
    context.get("resultSummary") match {
      case crs: ChainResultsSummary =>
        val pluginInfos = for {
          jobSummaries <- crs.getOrderedJobResultSummaries.asScala
          (key, pluginBinaryUrl) <- jobSummaries.getCustomBuildData.asScala if key == Constants.ResultLinkPluginBinaryUrl
          (key, pluginVersion) <- jobSummaries.getCustomBuildData.asScala if key == Constants.ResultLinkPluginVersion
        } yield (pluginBinaryUrl, pluginVersion)
        pluginInfos.toList match {
          case Nil => ""
          case (binaryUrl, version) :: _ =>
            s"""<p>$MpacLogoBase64Encoded <a href="$binaryUrl">Atlassian Marketplace version $version</a></p>"""
        }
      case _ => ""
    }

} 

//设置package包名称以及导入依赖的类
package ch.mibex.bamboo.shipit.task.artifacts

import java.io.File

import ch.mibex.bamboo.shipit.Utils
import com.atlassian.bamboo.plan.cache.ImmutableJob
import com.atlassian.bamboo.task.{CommonTaskContext, TaskContext}
import com.atlassian.bamboo.util.Narrow
import com.atlassian.bamboo.webwork.util.WwSelectOption
import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport
import com.atlassian.sal.api.message.I18nResolver
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Component

import scala.collection.JavaConverters._


@Component
class SubscribedArtifactCollector @Autowired() (@ComponentImport i18nResolver: I18nResolver) {

  def buildArtifactUiList(job: ImmutableJob): Seq[WwSelectOption] =
    job.getArtifactSubscriptions.asScala map { as =>
      val selectedValue = ArtifactSubscriptionId(as.getArtifactDefinition)
      val groupName = i18nResolver.getText("shipit.task.config.subscribed.artifacts")
      new WwSelectOption(as.getName, groupName, selectedValue.toString)
    }

  def findArtifactInSubscriptions(taskContext: CommonTaskContext, artifactId: Long): Option[File] = {
    val rootDir = taskContext.getWorkingDirectory
    val buildTaskContext = Narrow.downTo(taskContext, classOf[TaskContext])
    Option(buildTaskContext) flatMap { btc =>
      (btc.getBuildContext.getArtifactContext.getSubscriptionContexts.asScala collectFirst {
        case asc if asc.getArtifactDefinitionContext.getId == artifactId =>
          Utils.findMostRecentMatchingFile(asc.getArtifactDefinitionContext.getCopyPattern, rootDir)
      }).flatten
    }
  }

} 

//设置package包名称以及导入依赖的类
package com.github.swwjf.ws

import com.github.swwjf.errorhandling.WSException
import org.springframework.beans.BeanUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional

import scala.collection.JavaConversions._
import scala.compat.java8.OptionConverters.RichOptionalGeneric

@Service
class InfoService @Autowired()(infoRepository: InfoRepository) {

  def fetchAllInformation(): List[InfoResponseDTO] = {
    def jpaToResponse(jpa: InfoJPA): InfoResponseDTO = {
      val response = InfoResponseDTO(
        createdDate = jpa.createdData.toString,
        updatedDate = Option(jpa.updatedDate).map(_.toString).orNull
      )
      BeanUtils.copyProperties(jpa, response)
      response
    }

    infoRepository
      .findAll()
      .map(jpaToResponse)
      .toList
  }

  def saveInfo(infoRequestDTO: InfoRequestDTO): Unit = {
    def requestToJPA(request: InfoRequestDTO): InfoJPA = {
      val jpa = new InfoJPA
      BeanUtils.copyProperties(request, jpa)
      jpa
    }

    try {
      infoRepository.save(requestToJPA(infoRequestDTO))
    } catch {
      case e: DataIntegrityViolationException => throw new WSException("Invalid/duplicate label")
    }
  }

  @Transactional
  def updateInfo(info: InfoRequestDTO): Unit = {
    val infoJPA = infoRepository
      .findOneByLabel(info.label)
      .asScala
      .getOrElse(throw new WSException(s"Failed to find info by label ${info.label}"))
    infoJPA.setMainDetails(info.mainDetails)
    infoJPA.setComments(info.comments)
  }

} 

//设置package包名称以及导入依赖的类
package com.github.swwjf.config

import javax.persistence.EntityManagerFactory
import javax.sql.DataSource

import org.apache.commons.dbcp2.BasicDataSource
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties
import org.springframework.boot.context.properties.{ConfigurationProperties, EnableConfigurationProperties}
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder
import org.springframework.context.annotation.{Bean, Configuration, Primary}
import org.springframework.data.jpa.repository.config.EnableJpaRepositories
import org.springframework.orm.jpa.{JpaTransactionManager, LocalContainerEntityManagerFactoryBean}
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.annotation.EnableTransactionManagement

@Configuration
@EnableJpaRepositories(basePackages = Array(DBConfig.RootPackage))
@EnableTransactionManagement
@EnableConfigurationProperties(Array(classOf[JpaProperties]))
private class DBConfig {
  @Bean
  @ConfigurationProperties(prefix = "jdbc.datasource.ws")
  @Primary
  def wsDataSource(): DataSource =
    DataSourceBuilder
      .create()
      .`type`(classOf[BasicDataSource])
      .build()

  @Bean
  @Autowired
  def entityManagerFactory(builder: EntityManagerFactoryBuilder): LocalContainerEntityManagerFactoryBean =
    builder
      .dataSource(wsDataSource())
      .persistenceUnit("ws")
      .packages(DBConfig.RootPackage)
      .build()

  @Bean
  def transactionManager(entityManagerFactory: EntityManagerFactory): PlatformTransactionManager = {
    val txManager = new JpaTransactionManager()
    txManager.setEntityManagerFactory(entityManagerFactory)
    txManager
  }
}

private object DBConfig extends DBConstants

private sealed trait DBConstants {
  final val RootPackage = "com.github.swwjf"
}