Server Jobs

```
  job.configs = [{
    ident = "demoJob"
    schedule {
      // the first time of day the Import should run (this is the Server time!). (format is HH:mm)
      // Default is 01:00
      first.time = "03:00"
      // the first weekday if needed (e.g. to emulate once a week)
      // possible: "monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday" or "-" for nothing
      first.weekday = "tuesday"

      // the period the Adapter should call the Coop Webservice
      // Default is one day (1440 minutes) - be aware 1 minute is the smallest period possible
      // - and it must be greater than the time the import takes!
      // make also sure that the period is so that the import is at always the same time of day.
      interval.minutes = 2
    }
  }, {
    ident = "demoJobWithDefaultScheduler"
    schedule {
    }
  }, {
    ident = "demoJobWithoutScheduler"
  }]
```

```
// the Factory must be a Singleton
@Singleton
class DemoJobCreation @Inject()(demoJob: DemoJobProcess // each JobProcess is injected
                                , demoJobWithDefaultScheduler: DemoJobWithDefaultSchedulerActor
                                , demoJobWithoutScheduler: DemoJobWithoutSchedulerActor
                                , @Named("actorSchedulers") val actorSchedulers: ActorRef // needed to create Schedules
                                , actorSystem: ActorSystem // needed to create the JobActors
                              )(implicit val ec: ExecutionContext) // needed for async processing
  extends JobCreation {

  // create all JobActors
  private lazy val demoJobRef = actorSystem.actorOf(JobActor.props(jobConfigs(demoJobIdent), demoJob), demoJobIdent)
  private lazy val demoJobWithDefaultSchedulerRef = actorSystem.actorOf(JobActor.props(jobConfigs(demoJobWithDefaultSchedulerIdent), demoJobWithDefaultScheduler), demoJobWithDefaultSchedulerIdent)
  private lazy val demoJobWithoutSchedulerRef = actorSystem.actorOf(JobActor.props(jobConfigs(demoJobWithoutSchedulerIdent), demoJobWithoutScheduler), demoJobWithoutSchedulerIdent)

  // return the correct JobActor for a JobConfig
  def createJobActor(jobConfig: JobConfig): ActorRef = jobConfig.jobIdent match {
    case "demoJob" => demoJobRef
    case "demoJobWithDefaultScheduler" => demoJobWithDefaultSchedulerRef
    case "demoJobWithoutScheduler" => demoJobWithoutSchedulerRef
    case other => throw ServiceException(s"There is no Job for $other")
  }
}

``` 

```
@Singleton
class CalendarJobCreation @Inject()(calendarImporter: CalendarImporter // the import infrastructure
                                    , calendarService: CalendarService // the service to integrate
                                    , @Named("actorSchedulers") val actorSchedulers: ActorRef
                                    , actorSystem: ActorSystem
                                   )(implicit val mat: Materializer
                                     , val ec: ExecutionContext)
  extends JobCreation {

  def createJobActor(jobConfig: JobConfig): ActorRef = create(jobConfig)

  private def create(jobConfig: JobConfig): ActorRef = {
    // creates a JobProcess from the JobConfig, that includes a subWebPath sent by the client.
    val process = CalendarProcess(jobConfig, calendarImporter, calendarService)
    val jobActor = actorSystem.actorOf(JobActor.props(jobConfig, process))
    initSchedule(jobConfig, jobActor)
    jobActor
  }

  // return empty Map onStartUp - as the JobProcesses are created on the fly
  override def createJobActorsOnStartUp(): Map[JobConfig, ActorRef] = Map()

}
``` 

```
class GetStartedProcess @Inject()()
                             (implicit val mat: Materializer, val ec: ExecutionContext)
  extends JobProcess {

  val jobLabel = "GetStarted Job"

  def createInfo(): ProjectInfo = // check createInfo for adding more infos!
    createInfo(version.BuildInfo.version)

  // the process fakes some long taking tasks that logs its progress
  def runJob(user: String)
            (implicit logService: LogService
             , jobActor: ActorRef): Future[LogService] = {
    Future {
      logService.startLogging()
      val results = ... // e.g. call a service

      results.foreach(doSomeWork)
      logService // fluent api
    }
  }

  protected def doSomeWork(dr: GetStartedResult)
                          (implicit logService: LogService): LogEntry = {
    ...
    logService.log(ll, s"Job: $jobLabel $ll: ${dr.name}", detail)
  }
} 
```

```
class Module extends AbstractModule with AkkaGuiceSupport {

  def configure(): Unit = {
    bind(classOf[JobCreation])
      .to(classOf[GetStartedJobCreation])
      .asEagerSingleton() // make it eager - as the Job is static and created at startup

    ... // more configuration
  }
}
```