Vaadin 8 in Kotlin: Binding data

David Marko  10 February 2017 05:47:00
Binding from data bean to UI components is very common Vaadin feature. Vaadin 8 changes the API slightly and simplifies this operation.
Each item below references code comment number in code snippet below.

#1 : BeanBinder
 — bean binder is object that holds the state and organize validation and data conversions.

#2 : Binding fields
 — each field can be bound individually. We do binding from Vaadin UI component (e.g. TextField). Binding includes validators and possible data convertors.

#3 : Binding all field
s — besides individual bean bindings we can bind entire bean to UI components with binder.bindInstanceFields(this) . We can even combine individual field bindings with validator definitions and then we bind rest of the bean fields that don’t require any special handling.

#4 : Reading value from bean
 — binder.readBean(task) reads value from field and store it to UI components based on binding definitions …

#5 : Writing values back to bean
 — binder.writeBean(task) writes values entered to UI components back to data bean.

# 6 : Data class for your task object
. Kotlin allows very nice and compact syntax for data beans.

// #1

var binder = BeanBinder(Task::class.java)

var task: Task

....

// #2

binder.forField(subject).withValidator(StringLengthValidator(

        "Subject is required",3,60)

).bind("subject");


binder.forField(type).asRequired("Type is required")

        .bind("type");


// #3

binder.bindInstanceFields(this)

// #4

binder.readBean(task)

// #5

binder.writeBean(task)

....

// #6

data class Task(var subject: String, var description: String, var type:String, var dueDate: LocalDate)


There are many options available for data binding in Vaadin 8 documentation here.

You can find original blog post here.

Vaadin 8 in Kotlin: Data model changes — ComboBox, Grid …

David Marko  8 February 2017 05:11:00
There are many nice features promised to come with Vaadin version 8. You probably know that Vaadin 8 is JDK 1.8 optimized version and many related simplifications are available in API now. Lets look at some nice features related to data model closely. All examples below are created using Kotlin syntax.

ComboBox Items

Data source for ComboBox can be defined as a simple list of beans using setItems methods. Caption for ComboBox items displayed in browser can be defined as generator using setItemCaptionGenerator method. Its a real simplification as we can define lambda for caption computation from bean properties.

Kotlin language also brings some simplification by using ‘.apply’ method. We have less and more compact code.

val c = ComboBox().apply {

   setItems(

        listOf(

           Person("John", "2"), Person("Matt", "1"),

           Person("Jane", "3"), Person("Joe", "5")

        )

   )

   setItemCaptionGenerator { it.name + " - " + it.id }

   addValueChangeListener { println("Item selected ...") }

}


Grid — data providers

To set items for Grid component we can call setItems(listOf()) the same way we did for ComboBox above. But Grid component usually requires dynamic data, where we can add , remove or modify items and see Grid to refresh content  by following our changes. For this purpose we can define DataProvider that loads our data from list. Now, whenever we update our gridData list, we can then call grid.dataProvider.refreshAll() to let Grid refresh items on screen. So simple and straightforward.  

With Kotlin we used mutableListOf(…) to create list of beans quickly and ‘.apply’ to define Grid properties in one closed code block. The code looks quite nice and is easy to understand.

val gridData= mutableListOf(

       Person("Mark", "2"), Person("John", "1"),

       Person("Joe", "3"), Person("Dan", "4")

)


val grid = Grid().apply {

   dataProvider = DataProvider.create(gridData)

   addColumn { it.id }.setCaption("Id").setSortable(false)

   addColumn { it.name }.setCaption("Name")

   addSelectionListener {      
      Notification.show(it.firstSelected.get().name)

   }

}


You can find original blog post here.


Spring Boot: Spring Boot 1.4.x & Thymeleaf 3.x configuration

David Marko  6 February 2017 07:54:40
Thymeleaf is quite popular template engine widely used among Spring Boot developers. And we use it as well. While working with Spring Boot 1.4.x you will find that spring-boot-starter-thymeleaf is based on older Thymeleaf 2.x version, while there is Thymeleaf 3.x available for some time.

But wait, there is an easy way how to get latest Thymeleaf for my Spring Boot 1.4.x application. There are 3 simple steps to do so.

1. Reference Thymeleaf in build.gradle file
(assuming we have Gradle based Spring Boot project)

compile("org.springframework.boot:spring-boot-starter-thymeleaf")
compile ("org.thymeleaf.extras:thymeleaf-extras-springsecurity4:3.0.0.RELEASE")
compile ("io.github.jpenren:thymeleaf-spring-data-dialect:3.1.1")

2. Specify Thymeleaf version in build.gradle file
Here is the place to say that we want version 3.x of Thymeleaf library

ext["thymeleaf.version"] = "3.0.2.RELEASE"
ext["thymeleaf-layout-dialect.version"] = "2.0.1"

3.  (Optional) Create @Configuration class with Thymeleaf configuration options. Spring Boot with detect this and create appropriate beans.

@Configuration
public class ThymeleafConfig extends WebMvcConfigurerAdapter implements ApplicationContextAware {

    @Autowired
    private MessageSource messageSource;

    @Value("${thymeleaf.templates.cache}")
    String thymeleafCache;

    private ApplicationContext applicationContext;

    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    @Bean
    public ITemplateResolver templateResolver() {
        SpringResourceTemplateResolver templateResolver = new SpringResourceTemplateResolver();
        templateResolver.setApplicationContext(applicationContext);
        templateResolver.setPrefix("classpath:/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setTemplateMode("HTML");
        templateResolver.setCharacterEncoding("UTF-8");

        if (thymeleafCache.equals("true")){
            templateResolver.setCacheable(true);
        } else {
            templateResolver.setCacheable(false);
        }

        return templateResolver;
    }

    @Bean
    public SpringTemplateEngine templateEngine() {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();

        templateEngine.setEnableSpringELCompiler(true);
        templateEngine.setTemplateResolver(templateResolver());
        templateEngine.setMessageSource(messageSource);
        templateEngine.addDialect(new SpringDataDialect());

        return templateEngine;
    }

    @Bean
    public ViewResolver viewResolver() {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setTemplateEngine(templateEngine());
        return viewResolver;
    }
}


You can find original blog post here.


Spring Boot: Talking to Elasticsearch through JEST (REST api)

David Marko  3 February 2017 05:32:00
If you use Spring Boot with some database you are probably quite familiar with Spring Data project. This way we can use many database systems very standardized way. It includes Elasticsearch using Spring Data Elasticsearch project.  Spring Data Elasticsearch  talks to ES server using native port and there are situations when we may prefer using REST api here. And if we are in such situation, Jest library comes to rescue.

Jest is a Java HTTP Rest client for ElasticSearch and its API is very nice and straightforward. To use it in our Spring Boot application (assuming we have Gradle based app) we simply include …  

compile('io.searchbox:jest:2.0.4')


… into build.gradle file as an additional dependency. To use Jest we need JestClient as an entry point. From SpringBoot application perspective, we can define @Service bean that will create and hold connection object. Such service can be injected in our code later using @Autowire annotation. Implementation of minimal JestClient service can look like the following one.

@Service

public class JestClientService implements Serializable {

private static final long serialVersionUID = 1L;

JestClient client=null;

 
@Value(“${jest.elasticsearch.host}”)

String host;

 
@Value(“${jest.elasticsearch.port}”)

String port;

 
@Value(“${jest.elasticsearch.index}”)

String indexName;

/**

*
*/

public JestClient getClient() {

if (this.client==null){

GsonFireBuilder fireBuilder = new GsonFireBuilder();

fireBuilder.enableExposeMethodResult();

 
GsonBuilder builder = fireBuilder.createGsonBuilder();

builder.excludeFieldsWithoutExposeAnnotation();

 
final Gson gson = builder.setDateFormat(AbstractJestClient.ELASTIC_SEARCH_DATE_FORMAT).create();

System.out.println(“Establishing JEST Connection to Elasticsearch over HTTP: “+”http://”+this.host+”:”+this.port);

JestClientFactory factory = new JestClientFactory();

factory.setHttpClientConfig(new HttpClientConfig

.Builder(“http://”+this.host+”:”+this.port)

.multiThreaded(true)

.readTimeout(20000)

.gson(gson)

.build());

this.client = factory.getObject();

 
}

 
return this.client;

}

}


Jest library contains decent documentation and internal tests come as nice source of examples that are very easy to learn from.

You can find original blog post here.

Spring Boot: Webjars — bundle your favourite JS library easily

David Marko  1 February 2017 05:28:00
Probably every web application depends on some JavaScript library on CSS file. We have our own such files, but many are third party coming from other developers. Shared knowledge is nice. To include such third party library usually means to find the proper version, download it, unpack it and extract meaningful parts and put it inside out application structure. No way with web jars!

To bundle JS/CSS libraries similar way how we include java libraries into Spring Boot project, we can easily reference them inside build.gradle file (we are talking about Gradle based Spring Boot projects here, maven is quite similar). As an example we can include jQuery and Twitter Bootstrap into our project. To do so, simply open http://www.webjars.org/classic web site and find appropriate library and select version you require.

Image:Spring Boot: Webjars — bundle your favourite JS library easily

As we are running Gradle based project, we take gradle lib references and put them inside build.gradle the same way as we reference third party java libraries.

compile('org.webjars:bootstrap:3.3.7')

compile('org.webjars:jquery:2.2.1')


If we are editing Spring Boot project under IntelliJ with Gradle plugin, the project is getting updated and proper packages are downloaded and expanded. Ok, now we have both third party libraries somewhere under our project and we need to reference them in HTML. And this final part is quite easy as well. If we use Thymeleaf as a template engine, we can simply reference jQuery like this:



Everything is very straightforward and when we decide to upgrade to latest JQuery or Twitter Bootstrap after some time, we just change appropriate version number in build.gradle file.

You can find original blog post here ...

Spring Boot: Listening for incoming emails in our applications

David Marko  30 January 2017 05:31:00
There are several options how to process incoming emails in our applications. We can for example route email into standard mailbox and periodically download emails into our application with POP3 protocol. Or we can run our own SMTP server inside Spring Boot application. And this is the case!

Adding Spring Boot project dependency

I prefer using Gradle for all my Spring Boot projects so adding dependency means adding one line into build.gradle file in my project directory. SubethaSMTP is library that contains embeddable SMTP server implementation, great option for our purpose.

compile ("org.subethamail:subethasmtp:3.1.7")


Starting SMTP server when Spring Boot starts

SMTP is an active service that must be started during Spring Boot application startup. To do so, we can create @Service class, like the one below, with @PostConstruct and @PreDestroy annotated methods. We can also inject properties parameters that will help us to configure service properly. This code is detected during Spring Boot start up process and @PostConstruct method is run for us. We must not to forget to stop SMTP server in @PreDestroy method otherwise the service would occupy the TCP port.

@Service

public class SMTPServerService {

@Value(“${smtpserver.enabled}”)

String enabled=””;

@Value(“${smtpserver.hostName}”)

String hostName=””;

@Value(“${smtpserver.port}”)

String port=””;

SMTPServer smtpServer;

public SMTPServerService() {

}

@PostConstruct

public void start() {

if(enabled.equalsIgnoreCase(“true”)){

SimpleMessageListenerImpl l = new SimpleMessageListenerImpl();

smtpServer = new SMTPServer(new SimpleMessageListenerAdapter(l));

smtpServer.setHostName(this.hostName);

smtpServer.setPort(Integer.valueOf(port));

smtpServer.start();

System.out.println(“****** SMTP Server is running for domain “+smtpServer.getHostName()+” on port “+smtpServer.getPort());

} else {

System.out.println(“****** SMTP Server NOT ENABLED by settings “);

}

}

@PreDestroy

public void stop() {

if(enabled.equalsIgnoreCase(“true”)){

System.out.println(“****** Stopping SMTP Server for domain “+smtpServer.getHostName()+” on port “+smtpServer.getPort());

smtpServer.stop();

}

}

public boolean isRunning() {

return smtpServer.isRunning();

}

}


Processing incoming emails

While  starting SMTP server with code above, we specified ‘SimpleMessageListenerImpl()’ class as SMTP Server parameter. The processing class must implement ‘SimpleMessageListener’ that requires implementation of two methods only. Method accept can check originator / recipient emails and optionally allow or reject email delivery. Method deliver then processes email based on application logic. Everything is quite clear and processing requires minimal of code.

public class SimpleMessageListenerImpl implements SimpleMessageListener {

public SimpleMessageListenerImpl() {

}

@Override

public boolean accept(String from, String recipient) {

    return true;

}

@Override

public void deliver(String from, String recipient, InputStream data) {

 Session session = Session.getDefaultInstance(new Properties());

 MimeMessage m = new MimeMessage(session,data);

 ReceivedEmail email=new ReceivedEmail(m);
 // ... here we go with email message ...

}


You can find original blog post here ...

NET.Notes Desktop: Webový prohlížeč souborového systému

David Marko  27 January 2017 04:54:00
Sdílené adresáře na souborovém serveru jsou oblíbeným a rychlým způsobem, jak si uživatelé mezi sebou soubory sdílejí a vyměňují. V rámci lokální sítě se sdílenými složkami pracuje velmi rychle a zvládne to i běžný uživatel. Problém nastane, pokud je uživatel mimo síť, pracuje z domu, z hotelu apod. Pokud není použito nějaké specializované řešení, VPN nebo něco obdobného, tak je vnitrofiremní souborový server nedostupný. Pro tyto případy jsme do našeho systému NET.Notes začlenily modul, pomocí něhož je možné vybrané složky souborového systému zpřístupnit přes webové rozhraní.

Hlavní výhody
  • jednoduchý způsob jak zpřístupnit část vnitrofiremního souborového systému přes univerzální webové rozhraní
  • možnost ovlivnit, zda-li budou soubory pouze pro čtení a nebo budou mít uživatelé možnost do složek soubory nahrávat
  • možnost zpřístupnění souborového modulu jen vybraným uživatelům

Image:NET.Notes Desktop: Webový prohlížeč souborového systému

Spring Boot: Startup init through @PostConstruct

David Marko  25 January 2017 05:00:00
There are frequent situations when application requires to run custom code while starting up. There are several ways how to do it in Spring Boot, one of my favorites is to create @Component class with method annotated with @PostConstruct . This simple component class is scanned during Spring Boot application start and method annotated by @PostConstruct is run just after all services initialized. Such startup init component can inject / autowire custom managed services and use them for initialization. This way we can, for example, inject Spring Data repository and do some data initialization in our application.

The following code example is minimum class skeleton for our startup init class. We can have several @Component classes in our application with @PostConstruct annotation available. All these are going to be run during Spring Boot start up process.

@Component

public class StartUpInit {


@Autowired

CustomServiceExample customServiceExample;


@PostConstruct

public void init(){

   // init code goes here

}


}


See original blog post here.

NET.Notes Desktop: Posílání SMS zpráv z aplikací

David Marko  23 January 2017 05:00:00
Je mnoho způsobů, jak s námi může aplikace komunikovat. Pokud sedíme u počítače je pravděpodobné, že primární zdroj informací je pro nás počítač samotný. Co však když chceme dostávat informace, když k počítači přístup nemáme? Co více, když nemáme například ani přístup k firemní síti nebo internetu? V praxi vznikají mnohé situace, kdy potřebuje dostávat upozornění a to jak v nejkratší době a s velkou dostupností. Pro mnohé tyto případy je optimální použití automatického zasílání SMS zpráv, které nás zastihnou na našem mobilním zařízení i když nemáme mobilní data či jiné internetové připojení.

Image:NET.Notes Desktop: Posílání SMS zpráv z aplikací
Pro zasílání SMS zpráv z aplikací existuje nespočet služeb, které za poplatek SMS zprávy doručují. Pokud bychom chtěli více vnitrofiremní řešení (tzn. neplatit externímu doručovateli SMS zpráv), jednou z možností je využití bezplatné služby https://smsgateway.me, která k odesílání SMS využívá fyzické zařízení (mobilní telefon) zákazníka.

Služba je založena na následujícím principu
  • uživatel / aplikace si vytvoří v dané službě zdarma svůj účet.
  • jako komplementární prvek se na mobilní zařízení, které bude odpovědné za odesílání SMS zpráv, nainstaluje aplikace .
  • po instalaci mobilní aplikace a přihlášení vytvořeným účtem dojde k přidělení ID zařízení, potřebné pro programové posílání SMS zpráv
  • samotné odeslání SMS zprávy z aplikace se provádí prostřednictvím RESTové webové služby, které krom přihlašovacích údajů specifikujeme, přes jaké mobilní zařízení, na koho a jakou SMS zprávu chceme zaslat. Mobilní aplikace periodicky kontroluje seznam zpráv k odeslání, které na serveru služby čekají a provede jejich stažení a odeslání běžnou SMS.
  • k odesílání je tak používáno vlastní mobilní zařízení, čímž máme tuto věc pod kontrolou jak z technického, tak z finančního hlediska. Zbývá tak již jen domluvit s našim firemním operátorem nějaký výhodný, na SMS zaměřený tarif

Možnosti využití automatického zasílání SMS zpráv
  • zasílání notifikací z informačního systému běžným uživatelům například mimo pracovní hodiny
  • ověřování přihlašování do informačního systému prostřednictvím zaslání kontrolního kódu formou SMS (2 fázová autentizace)
  • zasílání notifikací o kritických stavem v IT systémech

NET.Notes Desktop: Autentizace vůči Active Directory

David Marko  19 January 2017 12:47:30
NET.Notes poskytuje několik způsobů jak autentizovat uživatele systému. Základem je vlastní uživatelská databáze, kde jsou přihlašovaní uživatelé autentizováni jménem a heslem v ní uloženým. Ne vždy je to ovšem optimální a často je potřeba zohlednit vnitrofiremní strategii práce s uživatelskými účty. NET.Notes tam nabízí několik technických způsobů, jak je možné uživatele autentizovat a tak docílit toho, že jsou přihlašovací informace v rámci firmy jednotné a spravované na jednom místě. K dispozici tak máme několik způsobů autentizace:
  • prostřednictvím vlastí aplikační databáze s přihlašovacími informacemi uživatelů
  • autentizace vůči obecnému firemnímu LDAP zdroji informací
  • autentizace vůči Active Directory
  • autentizace vůči jinému HTTP serveru
  • autentizace vůči POP3(mailovému) serveru
  • možnost tvorby zcela zákaznického způsobu autentizace

Autentizace vůči Active Directory je vhodnou variantou v prostředí používající Microsoft Windows server s existujícími přihlašovacími účty. Nastavení autentizace je z větší části konfigurační záležitostí NET.Notesu, nutno je však zajistit vytvoření záznamy do NET.Notesu, neboť k uživatelskému účtu jsou ukládány další systémové informace nutné pro chod systému. Autentizací vůči Active Directory nicméně docílíme jednotné správy uživatelského hesla a jeho změna v rámci Windows prostředí je tak následně reflektována v rámci NET.Notes přihlášení.

Image:NET.Notes Desktop: Autentizace vůči Active Directory
TOPlist