./grailsw create-domain-class Announcement
| Resolving Dependencies. Please wait...
CONFIGURE SUCCESSFUL
Total time: 4.53 secs
| Created grails-app/grails/company/intranet/Announcement.groovy
| Created src/test/groovy/grails/company/intranet/AnnouncementSpec.groovy

package intranet.backend

class Announcement {

    String title
    String body

    static constraints = {
        title size: 0..255
        body nullable: true
    }

    static mapping = {
        body type: 'text'  (1)
    }
}

package intranet.backend

import grails.testing.gorm.DomainUnitTest
import spock.lang.Specification

class AnnouncementSpec extends Specification implements DomainUnitTest<Announcement> {

    void "test body can be null"() {
        expect:
        new Announcement(body: null).validate(['body'])
    }

    void "test title can not be null"() {
        expect:
        !new Announcement(title: null).validate(['title'])
    }

    void "test body can have a more than 255 characters"() {

        when: 'for a string of 256 characters'
        String str = ''
        256.times { str += 'a' }

        then: 'body validation passes'
        new Announcement(body: str).validate(['body'])
    }

    void "test title can have a maximum of 255 characters"() {

        when: 'for a string of 256 characters'
        String str = ''
        256.times { str += 'a' }

        then: 'title validation fails'
        !new Announcement(title: str).validate(['title'])

        when: 'for a string of 256 characters'
        str = ''
        255.times { str += 'a' }

        then: 'title validation passes'
        new Announcement(title: str).validate(['title'])
    }
}

 ./grailsw test-app
 | Resolving Dependencies. Please wait...
 CONFIGURE SUCCESSFUL
 Total time: 2.534 secs
 :complete:compileJava UP-TO-DATE
 :complete:compileGroovy
 :complete:buildProperties
 :complete:processResources
 :complete:classes
 :complete:compileTestJava UP-TO-DATE
 :complete:compileTestGroovy
 :complete:processTestResources UP-TO-DATE
 :complete:testClasses
 :complete:test
 :complete:compileIntegrationTestJava UP-TO-DATE
 :complete:compileIntegrationTestGroovy UP-TO-DATE
 :complete:processIntegrationTestResources UP-TO-DATE
 :complete:integrationTestClasses UP-TO-DATE
 :complete:integrationTest UP-TO-DATE
 :complete:mergeTestReports

 BUILD SUCCESSFUL

 | Tests PASSED

$ curl -i -H "Accept-Version: 1.0" -X GET http://localhost:8080/announcements

$ curl -i -H "Accept-Version: 2.0" -X GET http://localhost:8080/announcements

package intranet.backend.v1

import grails.rest.RestfulController
import intranet.backend.Announcement

class AnnouncementController extends RestfulController<Announcement> {
    static namespace = 'v1' (1)
    static responseFormats = ['json'] (2)

    AnnouncementController() {
        super(Announcement)
    }
}

package grails.company.intranet

class BootStrap {

    def init = { servletContext ->
        announcements().each { it.save() }
    }
    def destroy = {
    }

    static List<Announcement> announcements() {
        [
                new Announcement(title: 'Grails Quickcast #1: Grails Interceptors'),
                new Announcement(title: 'Grails Quickcast #2: JSON Views')
        ]
    }
}

package intranet.backend

import grails.plugins.rest.client.RestBuilder
import grails.testing.mixin.integration.Integration
import org.springframework.beans.factory.annotation.Value
import spock.lang.Specification
import javax.servlet.http.HttpServletResponse


@Integration
class AnnouncementControllerSpec extends Specification {

    def "test body is present in announcements json payload of Api 1.0"() {
        given:
        RestBuilder rest = new RestBuilder()

        when: 'Requesting announcements for version 1.0'
        def resp = rest.get("http://localhost:${serverPort}/announcements/") { (1)
            header("Accept-Version", "1.0") (2)
        }

        then: 'the request was successful'
        resp.status == HttpServletResponse.SC_OK (3)

        and: 'the response is a JSON Payload'
        resp.headers.get('Content-Type') == ['application/json;charset=UTF-8']

        and: 'json payload contains an array of annoucements with id, title and body'
        resp.json.each {
            assert it.id
            assert it.title
            assert it.body (4)
        }
    }

    def "test body is NOT present in announcements json payload of Api 2.0"() {
        given:
        RestBuilder rest = new RestBuilder()

class Announcement {
    let primaryKey: Int
    let title: String
    var body: String?

    init(primaryKey: Int, title: String) {
        self.primaryKey = primaryKey
        self.title = title
    }
}

import Foundation

class AnnouncementBuilder {

    func announcementsFromJSON(_ data: Data?) -> [Announcement] {
        let json = try? JSONSerialization.jsonObject(with: data!, options: [])
        var announcements = [Announcement]()
        if let array = json as? [Any] {
            for object in array {
                if let dict = object as? Dictionary<String, AnyObject> {
                    if let title = dict["title"] as? String, let primaryKey = dict["id"]  as? Int {
                        let announcement = Announcement(primaryKey: primaryKey, title: title)
                        if let body = dict["body"]  as? String {
                            announcement.body = body
                        }
                        announcements.append(announcement)
                    }
                }
            }
        }
        return announcements
    }
}

struct GrailsApi {
    static let serverUrl = "http://192.168.1.40:8080" (1)
    struct Announcements {
        static let Path = "announcements" (2)
    }
    static let version = "1.0" (3)
}

import Foundation

class AnnouncementsFetcher : NSObject, URLSessionDelegate {

    weak var delegate:AnnouncementsFetcherDelegate?
    let builder = AnnouncementBuilder()

    func fetchAnnouncements() {
        let url = URL(string: "\(GrailsApi.serverUrl)/\(GrailsApi.Announcements.Path)")!
        let req = NSMutableURLRequest(url:url)
        req.setValue(GrailsApi.version, forHTTPHeaderField: "Accept-Version") (1)
        let config = URLSessionConfiguration.default
        let session = URLSession(configuration: config, delegate: self, delegateQueue: OperationQueue.main)

        let task = session.dataTask(with: req as URLRequest) { (data, response, error) in
            if error != nil {
                if let delegate = self.delegate {
                    delegate.announcementsFetchingFailed()
                }
                return
            }
            let announcements = self.builder.announcementsFromJSON(data)
            if let delegate = self.delegate {
                delegate.announcementsFetched(announcements)
            }

        }
        task.resume()

    }
}

protocol AnnouncementsFetcherDelegate: class {

    func announcementsFetchingFailed()

    func announcementsFetched(_ announcements: [Announcement])
}

import UIKit

class MasterViewController: UITableViewController, AnnouncementsFetcherDelegate {

    var detailViewController: DetailViewController? = nil
    var objects = [Any]()

    var tableViewDataSource = AnnouncementsTableViewDataSource()
    var tableViewDelegate = AnnouncementsTableViewDelegate()
    let fetcher = AnnouncementsFetcher()

    // MARK: - LifeCycle

    override func viewDidLoad() {
        super.viewDidLoad()
        self.tableView.dataSource = self.tableViewDataSource
        self.tableView.delegate = self.tableViewDelegate
        self.fetcher.delegate = self
    }

    override func viewWillAppear(_ animated: Bool) {
        self.clearsSelectionOnViewWillAppear = self.splitViewController!.isCollapsed
        super.viewWillAppear(animated)
        self.registerNotifications()
        self.fetchAnnouncements() (1)
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        self.unregisterNotifications()
    }

    // MARK: - Notifications

    func registerNotifications() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(self.announcementTapped),
            name: Notification.Name("AnnouncementTappedNotification"),
            object: nil)
    }

    func unregisterNotifications() {
        NotificationCenter.default.removeObserver(
            self,
            name: Notification.Name("AnnouncementTappedNotification"),
            object: nil)
    }

    // MARK: - Private Methods

    @objc func announcementTapped(notification: NSNotification){

        let announcement = notification.object as! Announcement
        self.performSegue(withIdentifier: "showDetail", sender: announcement)
    }

    func fetchAnnouncements() {
        self.setNetworkActivityIndicator(true)
        self.fetcher.fetchAnnouncements()
    }

    func setNetworkActivityIndicator(_ visible: Bool) {
        UIApplication.shared.isNetworkActivityIndicatorVisible = visible
    }

    // MARK: - Segues

    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        if segue.identifier == "showDetail" {
            let controller = (segue.destination as! UINavigationController).topViewController as! DetailViewController
            if let announcement = sender as? Announcement {
                controller.announcement = announcement
            }
            controller.navigationItem.leftBarButtonItem = self.splitViewController?.displayModeButtonItem
            controller.navigationItem.leftItemsSupplementBackButton = true
        }
    }

    // MARK: - AnnouncementsFetcherDelegate

    func announcementsFetchingFailed() {
        self.setNetworkActivityIndicator(false)
    }

    func announcementsFetched(_ announcements: [Announcement]) {  (2)
        self.setNetworkActivityIndicator(false)

        self.tableViewDataSource.announcements = announcements
        self.tableViewDelegate.announcements = announcements
        self.tableView.reloadData()
    }
}

import UIKit

class AnnouncementsTableViewDataSource : NSObject, UITableViewDataSource {

    var announcements = [Announcement]()


    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return announcements.count
    }

    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {

        let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)

        let announcement = announcements[indexPath.row]
        cell.textLabel!.text = announcement.title
        return cell
    }
}

import UIKit

class AnnouncementsTableViewDelegate : NSObject, UITableViewDelegate {

    var announcements = [Announcement]()

    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        let announcement = announcements[indexPath.row]
        NotificationCenter.default.post(name: Notification.Name("AnnouncementTappedNotification"), object: announcement) (1)
    }

}

    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        if segue.identifier == "showDetail" {
            let controller = (segue.destination as! UINavigationController).topViewController as! DetailViewController
            if let announcement = sender as? Announcement {
                controller.announcement = announcement
            }
            controller.navigationItem.leftBarButtonItem = self.splitViewController?.displayModeButtonItem
            controller.navigationItem.leftItemsSupplementBackButton = true
        }

import UIKit

class DetailViewController: UIViewController, UIWebViewDelegate {

    @IBOutlet weak var titleLabel: UILabel!
    @IBOutlet weak var webView: UIWebView!
    @IBOutlet weak var activityIndicatorView: UIActivityIndicatorView!

    func configureView() {
        // Update the user interface for the detail item.
        if let announcement = self.announcement {
            if let label = self.titleLabel {
                label.text = announcement.title
            }
            if let webView = self.webView, let body = announcement.body {
                self.hideActivityIndicator()
                webView.loadHTMLString(body, baseURL: nil)
            } else {
                self.hideActivityIndicator()
            }
        } else {
            self.hideActivityIndicator()
        }
    }

    func hideActivityIndicator() {
        if let activityIndicatorView  = self.activityIndicatorView {
            activityIndicatorView.stopAnimating()
        }
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
        self.configureView()
    }

    var announcement: Announcement? {
        didSet {
            // Update the view.
            self.configureView()
        }
    }


    // MARK: - UIWebViewDelegate

    func webViewDidFinishLoad(_ webView: UIWebView) {
        self.hideActivityIndicator()
    }

    func webView(_ webView: UIWebView, didFailLoadWithError error: Error) {
        self.hideActivityIndicator()
    }
}

package intranet.backend.v2

import grails.rest.RestfulController
import intranet.backend.Announcement

class AnnouncementController extends RestfulController<Announcement> {
    static namespace = 'v2'
    static responseFormats = ['json']

    def announcementService

    AnnouncementController() {
        super(Announcement)
    }

    def index(Integer max) {
        params.max = Math.min(max ?: 10, 100)
        def announcements = announcementService.findAllIdAndTitleProjections(params)
        respond announcements, model: [("${resourceName}Count".toString()): countResources()]
    }
}

package intranet.backend

import grails.transaction.Transactional

@Transactional(readOnly = true)
class AnnouncementService {

    List<Map> findAllIdAndTitleProjections(Map params) {
        def c = Announcement.createCriteria()
        def announcements = c.list(params) {
            projections {
                property('id')
                property('title')
            }
        }.collect { [id: it[0], title: it[1]] } as List<Map>
    }
}

package intranet.backend

import grails.test.hibernate.HibernateSpec
import grails.testing.services.ServiceUnitTest

class AnnouncementServiceSpec extends HibernateSpec implements ServiceUnitTest<AnnouncementService> {

    def "test criteria query with projection returns a list of maps"() {

        when: 'Save some announcements'
        [new Announcement(title: 'Grails Quickcast #1: Grails Interceptors'),
        new Announcement(title: 'Grails Quickcast #2: JSON Views'),
        new Announcement(title: 'Grails Quickcast #3: Multi-Project Builds'),
        new Announcement(title: 'Grails Quickcast #4: Angular Scaffolding'),
        new Announcement(title: 'Retrieving Runtime Config Values In Grails 3'),
        new Announcement(title: 'Developing Grails 3 Applications With IntelliJ IDEA')].each {
            it.save()
        }

        then: 'announcements are saved'
        Announcement.count() == 6

        when: 'fetching the projection'
        def resp = service.findAllIdAndTitleProjections([:])

        then: 'there are six maps in the response'
        resp
        resp.size() == 6

        and: 'the maps contain only id and title'
        resp.each {
            it.keySet() == ['title', 'id'] as Set<String>
         }

        and: 'non empty values'
        resp.each {
            assert it.title
            assert it.id
        }

    }
}

package intranet.backend

import grails.plugins.rest.client.RestBuilder
import grails.testing.mixin.integration.Integration
import org.springframework.beans.factory.annotation.Value
import spock.lang.Specification
import javax.servlet.http.HttpServletResponse


@Integration
class AnnouncementControllerSpec extends Specification {

    def "test body is present in announcements json payload of Api 1.0"() {
        given:
        RestBuilder rest = new RestBuilder()

        when: 'Requesting announcements for version 2.0'
        def resp = rest.get("http://localhost:${serverPort}/announcements/") {
            header("Accept-Version", "2.0")
        }

        then: 'the request was successful'
        resp.status == HttpServletResponse.SC_OK

        and: 'the response is a JSON Payload'
        resp.headers.get('Content-Type') == ['application/json;charset=UTF-8']

        and: 'json payload contains an array of annoucements with id, title'
        resp.json.each {
            assert it.id
            assert it.title
            assert !it.body (2)
        }
    }

    def "test detail of an announcement contains body in both version 1.0 and 2.0"() {
        given:

struct GrailsApi {
    static let serverUrl = "http://192.168.1.40:8080"
    static let version = "2.0" (1)
    struct Announcements {
        static let Path = "announcements"
    }
}

    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        if segue.identifier == "showDetail" {
            let controller = (segue.destination as! UINavigationController).topViewController as! DetailViewController
            if let announcement = sender as? Announcement {
                controller.announcementPrimaryKey = announcement.primaryKey
            }
            controller.navigationItem.leftBarButtonItem = self.splitViewController?.displayModeButtonItem
            controller.navigationItem.leftItemsSupplementBackButton = true
        }
    }

import UIKit

class DetailViewController: UIViewController, UIWebViewDelegate, AnnouncementFetcherDelegate {

    @IBOutlet weak var titleLabel: UILabel!
    @IBOutlet weak var webView: UIWebView!
    @IBOutlet weak var activityIndicatorView: UIActivityIndicatorView!

    let fetcher = AnnouncementFetcher()

    // MARK: - LifeCycle

    override func viewDidLoad() {
        super.viewDidLoad()
        self.fetcher.delegate = self
        self.configureView()
    }

    func configureView() {
        // Update the user interface for the detail item.
        if let announcement = self.announcement {
            if let label = self.titleLabel {
                label.text = announcement.title
            }
            if let webView = self.webView, let body = announcement.body {
                self.hideActivityIndicator()
                webView.loadHTMLString(body, baseURL: nil)
            } else {
                self.hideActivityIndicator()
            }
        }
    }

    var announcement: Announcement? {
        didSet {
            self.configureView()
        }
    }

    var announcementPrimaryKey: Int? {
        didSet {
            self.showActivityIndicator()
            self.fetcher.fetchAnnouncement(self.announcementPrimaryKey!)
        }
    }

    // MARK: - Private Methods
    func showActivityIndicator() {
        if let activityIndicatorView  = self.activityIndicatorView {
            activityIndicatorView.startAnimating()
        }
    }

    func hideActivityIndicator() {
        if let activityIndicatorView  = self.activityIndicatorView {
            activityIndicatorView.stopAnimating()
        }
    }


    // MARK: - UIWebViewDelegate

    func webViewDidFinishLoad(_ webView: UIWebView) {
        self.hideActivityIndicator()
    }

    func webView(_ webView: UIWebView, didFailLoadWithError error: Error) {
        self.hideActivityIndicator()
    }

    // Mark: - AnnouncementFetcherDelegate

    func announcementFetchingFailed() {

    }

    func announcementFetched(_ announcement: Announcement) {
        self.announcement = announcement
    }
}

import Foundation

class AnnouncementFetcher : NSObject, URLSessionDelegate {

    weak var delegate: AnnouncementFetcherDelegate?
    let builder = AnnouncementBuilder()

    func fetchAnnouncement(_ primaryKey: Int) {
        let url = URL(string: "\(GrailsApi.serverUrl)/\(GrailsApi.Announcements.Path)/\(primaryKey)")!
        let req = NSMutableURLRequest(url:url)
        req.setValue(GrailsApi.version, forHTTPHeaderField: "Accept-Version") (1)
        let config = URLSessionConfiguration.default
        let session = URLSession(configuration: config, delegate: self, delegateQueue: OperationQueue.main)

        let task = session.dataTask(with: req as URLRequest) { (data, response, error) in
            if error != nil {
                if let delegate = self.delegate {
                    delegate.announcementFetchingFailed()
                }
                return
            }
            if let announcement = self.builder.announcementFromJSON(data) {
                if let delegate = self.delegate {
                    delegate.announcementFetched(announcement)
                }
            } else {
                if let delegate = self.delegate {
                    delegate.announcementFetchingFailed()
                }
            }

        }
        task.resume()

    }
}

    func announcementFromJSON(_ data: Data?) -> Announcement? {
        let json = try? JSONSerialization.jsonObject(with: data!, options: [])
        if let dict = json as? Dictionary<String, AnyObject> {
            if let title = dict["title"] as? String, let primaryKey = dict["id"]  as? Int {
                let announcement = Announcement(primaryKey: primaryKey, title: title)
                if let body = dict["body"]  as? String {
                    announcement.body = body
                }
                return announcement

            }
        }
        return nil
    }

protocol AnnouncementFetcherDelegate: class {

    func announcementFetchingFailed()

    func announcementFetched(_ announcement: Announcement)
}