How to send DELETE HTTP request in HttpURLConnection java

In a DELETE request, the parameters are sent as part of the URL and you can not send request body.

This code should get you started:

String urlParameters = "param1=1&param2=2";
String request = "http://api.server.com";
URL url = new URL(request + "?" + urlParameters); 
HttpURLConnection connection = (HttpURLConnection) url.openConnection(); 
connection.setDoInput(true);
connection.setInstanceFollowRedirects(false); 
connection.setRequestMethod("DELETE"); 
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); 
connection.setRequestProperty("charset", "utf-8");
connection.setUseCaches (false);

Print out response code and get response from server:

System.out.println("Response code: " + connection.getResponseCode());

BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));
String line, responseText = "";
while ((line = br.readLine()) != null) {
    System.out.println("LINE: "+line);
    responseText += line;
}
br.close();
connection.disconnect();

Transactions in Grails to roll back inconsistent data

The withTransaction function will participate in an existing transaction if one already has been started and would start a new one if not. The withNewTransaction method will always start a new transaction regardless of if one has already been started, isolating the code inside that block into it's own transaction (with it's own commit/rollback).

If you think the method you are developing should or could participate in some larger transaction with multiple separate db writes, then you should use withTransaction so that you can participate in a larger transaction if necessary. If you want your write here to be totally isolated from other db writes if another transaction is going on (and not potentially roll back that other transaction if this code fails), then use withNewTransaction.

In regards to your question two, these two will behave the same if they are the only calls being made in an action as they would both start up a new transaction.

def saveInstance = {
   /* Assume 'User' and 'Role' are two difference domain.
   Where Role is as a belongsTo of User.
   So need to first save Role and then User.
   But if Role saved and User not saved for any reason, then what happened???
   Role exists in database???
   For this we need to roll back data.
   Everything inside this block is run in a transaction as the name indicates. */
   User.withTransaction { status ->
      try {
          def role = new Role(rollName: "Role Name").save(flush: true);
          def user = new User(username: "pritom", name: "Pritom K Mondal", role: role).save(flush: true);
      } catch (Exception ex) {
          ex.printStackTrace();
          try {
              /* Rolling back data if any exception happens */
              status.setRollbackOnly();
          } catch (Exception ex2) {
              ex2.printStackTrace();
          }
      }
   }
}

Sort an ArrayList base on multiple attributes using java/grails

I have an ArrayList of object. The object contain attributes name and classValue. So I want to sort the objects on the classValue, and for all objects in the same classValue I want to sort them on name.

---

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;

/**
 *
 * @author Pritom Kumar
 */
public class MapSort {
    public static void main(String[] args) {
        MapSort mapSort = new MapSort();
        mapSort.sort();
    }
    
    public void sort() {
        List keys = new ArrayList();
        HashMap map1 = new HashMap();
        map1.put("name", "Pritom");
        map1.put("classValue", 5);
        keys.add(map1);
        
        HashMap map2 = new HashMap();
        map2.put("name", "Bappi Lahiri");
        map2.put("classValue", 10);
        keys.add(map2);
        
        HashMap map3 = new HashMap();
        map3.put("name", "Ashok Kumar");
        map3.put("classValue", 5);
        keys.add(map3);

        Collections.sort(keys,
            new Comparator() {
                public int compare(Object left, Object right) {
                    HashMap leftMap = (HashMap) left;
                    HashMap rightMap = (HashMap) right;
                    Integer classValue1 = Integer.parseInt(leftMap.get("classValue").toString());
                    Integer classValue2 = Integer.parseInt(rightMap.get("classValue").toString());
                    int comp = classValue1.compareTo(classValue2);
                    return comp == 0 ? leftMap.get("name").toString().compareTo(rightMap.get("name").toString()) : comp;
                }
            });

        //List the values
        Object[] keyList = keys.toArray();
        for(Integer index = 0; index < keyList.length; index++) {
            System.out.println(keyList[index]);
        }
    }
}

And the output is as following. At first sorts by classValue and then by name.

{name=Ashok Kumar, classValue=5}
{name=Pritom, classValue=5}
{name=Bappi Lahiri, classValue=10}

Grails/GORM createCriteria.list to get specific/selected columns only | Alias To Entity Map ALIAS_TO_ENTITY_MAP | Grails Projections | Projections Data

Grails/GORM createCriteria.list to get specific/selected columns only | Alias To Entity Map ALIAS_TO_ENTITY_MAP | Grails Projections | Projections Data.

Below is a example of get some specific field instead of all fields for domain.

And you can left join another domain that is belongsTo or hasMany of parent domain.

You have to import below reference:
import org.hibernate.criterion.CriteriaSpecification

List list = DomainName.createCriteria().list {
    resultTransformer(CriteriaSpecification.ALIAS_TO_ENTITY_MAP)
    "in"("id", [1L, 2L])
    createAlias('x', 'x_alias', CriteriaSpecification.LEFT_JOIN)
    projections {
        property("id", "id")
        property("x_alias.field", "field_reference");
    }
}

Output would be like below:

[
    [id:1, field_reference:value1],
    [id:2, field_reference:value2]
] 

Grails get post/put raw request body

There may be situation where the data in body for the request is need to be read. To read the raw data:

request.getReader().text

However, this will give the following error:
getInputStream() has already been called for this request

This is because the default request parser needs to be turned off before reading the body text. Here is one way how to do it in the grails-app/conf/UrlMapping:

class UrlMappings {     static mappings = {         "/api/review/$id?"(controller: 'review', parseRequest: false){             action = [ PUT: "update", POST: "save", GET: "show"]         } ... }

By specifying ‘parseRequests: false’ in highlighted line, it will turn off the Grails automatic parsing and make it possible to read the body data (i.e. request.getReader().text)

You can read request body in your filters before method and parse if need as you wish.
 

Grails GORM constrained properties: check if a domain attributes properties mapping

Consider a grails domain class like below:

---

package com.pritom.domains.customer

class Customer {
    Integer id;
    String customerId
    String email;
    String password
    Date dateCreated = new Date()
    Date lastUpdated = new Date()

    static mapping = {

    }

    static constraints = {
        customerId unique: true
        email unique: true
        creditCard(nullable: true);
    }
}

Now get domain class constrained properties:

---

def domainClass = new DefaultGrailsDomainClass(com.pritom.domains.Customer)
def constrainedProperties = domainClass.constrainedProperties;

Now check if specific field has some specific property

---

String key = "customerId";

if (constrainedProperties.containsKey(key)) {
    ConstrainedProperty v = (ConstrainedProperty) constrainedProperties.get(key);
    if(v.isNullable()) println 'Nullable';
    if(v.isBlank()) println 'Blank';
    if(v.isCreditCard()) println 'Credit Card';
    if(v.isDisplay()) println 'Display';
    if(v.isEditable()) println 'Editable';
    if(v.isEmail()) println 'Email';
}

And you can check more properties as you wish.

http://pritomkumar.blogspot.com/2013/09/javagrails-class-constrainedproperty.html

Duplicated records/data persistence/flush session error with Grails in synchronized method

Consider some of cases: 

1. When domain fails to save data because of duplicate record.
2. When an unsaved domain belongsTo a domain, then showing: 'save the transient instance before flushing'.

Then  - Domain.save(flush:true) - didn't work because of threading.
Here is example of my thread creation:

Thread.start {
    Domain.withTransaction {
         // Doing stuff and calling synchronization method to write data to DB
    }
}

Fix was found here: Grails, GPars and data persistence
I replaced "Domain.withTransaction" with "Domain.withNewSession":

Thread.start {
    Domain.withNewSession {
         // Doing stuff and calling synchronization method to write data to DB
    }
}

and save(flush:true) start writing into mySQL. Since data is written to mySQL, findBy... start returning proper results and therefore I application doesn't try to create duplicated record anymore. Issue solved!