Installation

To install the latest official version, use NPM:

npm install jasmine-node -g

Write the specifications for your code in *.js and *.coffee files in the spec/ directory

Execution

After installing the npm package, you can run it with:

jasmine-node spec/filename.js
jasmine-node spec/filename.coffee

For executing multiple test files you can provide multiple filenames as an argument to jasmine-node command.

Key features :

1. Behavior driven.
2. It does not require DOM for testing.
3. Clean and obvious syntax.

Test Cases :

SUITES
Call to a global function ‘describe’ which takes arguments a String and function. The function is a block of code that implements the suite.The String describes the title for the suit.

SPECS
Call to global Jasmine function ‘it’, which like ‘describe’ takes a string and a function. The string is a title for this spec and the function is the spec, or test. A spec contains one or more expectations that examine the state of the code under test,their can be as many ‘it’ functions in describe block.

EXPECTATION
Expectation in jasmine is an assertion which results either true or false. Their can be as many assertions in a spec. Expectations are genrated with the function ‘expect’ which takes an argument which is the actual value. It is chained with a Matcher function, which takes the expected value.

MATCHERS

Each matcher implements the Boolean comparison between actual and expected value. Matchers are used to compare both the values and if all matchers matches or return true only then test is considered as passed else it is considered as failure. Some of the matchers functions are ‘toBe’, ‘toBeTruthy’ etc.
Some examples are as follows:

expect(x).toEqual(y); // compares objects or primitives x and y and passes if they are equivalent
expect(x).toBe(y); // compares objects or primitives x and y and passes if they are the same object
expect(x).toMatch(pattern); //compares x to string or regular expression pattern and passes if they match

beforeEach() and afterEach()

Function ‘beforeEach’ performs task that is to be performed before test begins and ‘afterEach’ performs task that is to be performed after test finished execution.

Sample test

describe("A suite", function() {
var a;

it("A spec", function() {
a = true;

expect(a).toBe(true);
expect(a).not.toBe(false);
});
});

Sahil Chitkara
Software Trainee
Intelligrape Software

Now to access your Google drive in your grails application you may save the client ID, client secret and redirect URL in Config.groovy like this:

 googleDrive{
  redirectURL = "Redirect Url"
  clientId  = "Client Id"
  clientSecret= "Client Secret"
}

Add following  dependencies in BuildConfig.groovy to import jars for accessing google documents and OAuth authorization:

compile "com.google.gdata:core:1.47.1"
compile "com.google.apis:google-api-services-drive:v2-rev72-1.14.2-beta"
compile "com.google.http-client:google-http-client-jackson:1.14.1-beta"

To access authorized user’s google drive, you need to get an authorization URL. User of the application must access this URL to authorize the application with Google and generate the authorization code. Following sample action generates the required authorization URL:

def index = {
   String clientId = grailsApplication.config.googleDrive.clientId
   String redirectURL = grailsApplication.config.googleDrive.redirectURL
   //List of scopes for which to request access
   List scopes =["https://spreadsheets.google.com/feeds", "https://docs.google.com/feeds"];
   String authorizationUrl =
   new GoogleAuthorizationCodeRequestUrl(clientId , redirectURL, scopes).build();
   redirect(url: authorizationUrl)
 }

The browser will redirect to the URL you specified in the redirectUrl parameter with the authorization code. Here is a sample redirect action which sets the authorization code in session.

def callback(String code) {
  HttpSession session = request.getSession();
  session.code = code;
  setCredential()
}

The setCredential() method generates the access token and sets its value in the session.

def setCredential() {
  HttpTransport transport = new NetHttpTransport()
  JacksonFactory jsonFactory = new JacksonFactory()
  String clientId = grailsApplication.config.googleDrive.clientId
  String clientSecret = grailsApplication.config.googleDrive.clientSecret
  String redirectUrl = grailsApplication.config.googleDrive.redirectURL
  GoogleTokenResponse response = new GoogleAuthorizationCodeTokenRequest
  (transport, jsonFactory, clientId, clientSecret,session.code, redirectUrl).execute();
  GoogleCredential accessToken = new GoogleCredential.Builder()
  .setClientSecrets(clientId, clientSecret)
  .setJsonFactory(jsonFactory).setTransport(transport).build()
  .setAccessToken(response.getAccessToken()).setRefreshToken(response.getRefreshToken());
  session.accessToken = accessToken
}

Once you have the access token you may access google drive. Following code snippet returns a list of all spreadsheets. Now you can view, edit, delete and manipulate your spreadsheets using Google Spreadsheet API.

SpreadsheetService service = new SpreadsheetService("MySpreadsheetService");
service.setOAuth2Credentials(session.accessToken)
URL sheetFeedUrl = new URL("https://spreadsheets.google.com/feeds/spreadsheets/private/full")
SpreadsheetFeed feed = service.getFeed(sheetFeedUrl,SpreadsheetFeed.class);
List spreadsheets = feed.getEntries()

Following is the code for reading data from first spreadsheet from the list retrieved above:

List worksheets = spreadsheets.get(0).getWorksheets();
worksheets.each{worksheet->
URL listFeedUrl = worksheet.getListFeedUrl();
ListFeed listFeed = service.getFeed(listFeedUrl, ListFeed.class);
listFeed.entries.each{row->
row.customElements.tags.each{tag->
   println "Column: ${tag} -- Value: ${row.getCustomElements().getValue(tag)}"
  }
 }
}

Helpful links:

https://code.google.com/apis/console/

https://developers.google.com/google-apps/spreadsheets/

Hope it helps!!
Paridhi Goel
paridhi@intelligrape.com

var http = require("http");
var requestHandler = function(request, response) {
  console.log("Request received.");
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.write("Hello World");
  response.end();
};
var server = http.createServer(requestHandler);
server.listen(9999);
console.log("Server has started.");

Now run the code. To run the server.js script with Node.js type below command:

node server.js

Now open your favorite browser and hit it at http://localhost:9999/. This should display a web page that says “Hello World!”. Well, now lets analyze what’s actually going on here.

1. The first line requires the http module that ships with Node.js and makes it accessible through the variable http.
2. We definded a requestHandler funciton to handle all the requests.
3. We called one of the functions that http module offers: createServer. This function returns an object, which we store in server.
4. This(server) object has a method named listen, and takes a numeric value which indicates the port number our HTTP server is going to listen.

Now lets analyze the, how requestHandler handling the requests. Whenever a request received, requestHandler function gets triggered and two parameters are passed into it, request and response.

1. response.writeHead() send an HTTP status and content-type in the HTTP response header.
2. response.write() send the text “Hello World” in the HTTP response body.
3. response.end() finish response.

Amit Kumar
amit.kumar@intelligrape.com
in.linkedin.com/in/amitkumar0110
twitter.com/amit_kumar0110
More Blogs by Me

]]> http://www.intelligrape.com/blog/2013/05/10/create-basic-http-server-with-node-js/feed/ 0 http://www.intelligrape.com/blog/2013/04/25/angularjs-getting-started-with-directives/ http://www.intelligrape.com/blog/2013/04/25/angularjs-getting-started-with-directives/#comments Thu, 25 Apr 2013 11:36:57 +0000 Suroor Wijdan http://www.intelligrape.com/blog/?p=10226 In this post we will go through an important aspect of AngularJS i.e., Directives.

Directives helps us do things in a better and cleaner way. Lets get into the code rather going into theoretical explanations, which will make it more clear what actually directives do.

We have written a simple directive below which shows some HTML when the element being created is encountered.

<html>
<head>
<title>Testing Directive</title>
<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.1/angular.min.js"></script>
</head>

<body>
<div ng-app="FirstDirective">
    <mytag></mytag>
</div>

<script>

myApp = angular.module("FirstDirective",[]);

myApp.directive('mytag',function(){
    return {
        restrict: "E",
        template: "<strong>This is a great First Directive</strong>",
        replace: true,
    }
})

</script>

</body>
</html>

In the above code, we have “mytag” element which when encountered in HTML renders the corresponding template.  Lets see what the code does,

myApp.directive() is another syntax that we have to remember. The first argument in this is the name of the tag that you want, in our case its “mytag”. Second thing is a factory function which returns an object that defines the directive properties.

In this object we have set “restrict” as E which makes it an Element that can be used like any of HTML tags. The second option “template” defines the HTML template to be loaded and the third option “replace” if set to true replaces the current element with the template.

We will learn more about other options available to us in the next post.

Hope it Helps! Feel free to ask if you have any queries.

dependencies {
        compile 'com.jcraft:jsch:0.1.49'
    }

2. Create a class for adding ftp credentials information. e.g. “FtpCredentail”

class FtpCredential {

    String server
    String username
    String password
    String remoteBaseDir
    Integer port
}

3. Create a service named “FtpService” and add the following code into it

import com.jcraft.jsch.Channel
import com.jcraft.jsch.ChannelSftp
import com.jcraft.jsch.JSch
import com.jcraft.jsch.Session

class FtpService {
    def grailsApplication

    static transactional = true

    def save(InputStream inputStream, String fileName, FtpCredential ftpCredential) {
        connect(ftpCredential) { ChannelSftp sftp ->
            sftp.put inputStream, fileName
        }
    }

    def load(String fileName, FtpCredential ftpCredential) {
        connect(ftpCredential, { ChannelSftp sftp ->
            File outputFile = File.createTempFile(fileName,'')
            outputFile?.newOutputStream() << sftp.get(fileName)
            outputFile
        }, false)
    }

    def delete(String fileName, FtpCredential ftpCredential) throws Throwable {
        connect(ftpCredential) { ChannelSftp sftp ->
            sftp.rm fileName
        }
    }

    def makeDir(String directoryName, FtpCredential ftpCredential) {
        connect(ftpCredential) { ChannelSftp sftp ->
            sftp.mkdir directoryName
        }
    }

    private def connect(FtpCredential ftpCredential, Closure c, boolean disconnectOnFinish = true) {
        Session session = null
        ChannelSftp sftp = null
        try {
            JSch jSch = new JSch()
            session = jSch.getSession username, ftpCredential?.server, ftpCredential?.port
            session.setConfig "StrictHostKeyChecking", "no"
            File keyFile = new File("${grailsApplication.config.pathToKeyFile}")
            if (ftpCredential?.password) {
                session.password = ftpCredential?.password
            } else {
                jSch.addIdentity(keyFile?.absolutePath)
            }
            session.connect()
            Channel sFtpChannel = session.openChannel "sftp"
            sFtpChannel.connect()
            sftp = sFtpChannel as ChannelSftp
            sftp.cd ftpCredential?.remoteBaseDir
            c.call sftp
        } catch (Exception ex) {
            ex.printStackTrace()
        } finally {
            if (disconnectOnFinish) {
                sftp?.exit()
                session?.disconnect()
            }
        }
    }
}

Note: In the above code at line number 44.

File keyFile = new File("${grailsApplication.config.pathToKeyFile}")

The code looks for private key provided by ftp server for password-less log in. One should define the property named “pathToKeyFile” in “grails-app/conf/Config.groovy” with value equals to the path of key file.

Now you are ready to use the newly created FtpService service methods. Such as:

1. save(inputStream, fileName, ftpCredential) for saving file over ftp.
2. load(fileName, ftpCredential) for getting file from ftp.
3. delete(fileName, ftpCredential) for deleting file over ftp.
4. makeDir(directoryName, ftpCredential) for creating directory over ftp.

Example

For saving file over ftp one can use FtpService save method as shown below

 File file = File.createTempFile("temp","txt")
 FtpCredential ftpCredential = new FtpCredential(server: <server>, username: <username>, password: <password>, port: <server_port>, remoteBaseDir: <remote_base_directory>)
 InputStream inputStream = new BufferedInputStream(new FileInputStream(file))
 ftpService.save(inputStream, "fileNameToBeSavedOverFTPServer", ftpCredential)

Please share your feedback and suggestions.

Click here to read more JSch examples »

Puneet Behl
puneet.behl@intelligrape.com
https://twitter.com/puneetbhl
http://in.linkedin.com/in/puneetbhl

var reduceFunction = function(currentDocument, previousDocument) {
     previousDocument.totalRating += currentDocument.rating; previousDocument.count += 1
};

var finalizeFunction = function(currentDocument) {
     currentDocument.average = currentDocument.totalRating/currentDocument.count;
     delete currentDocument.totalRating;
     delete currentDocument.count;
};

db.userquestions.group({
     key: {'quesId': true},
     initial: {totalRating: 0, count:0},
     reduce: reduceFunction,
     finalize:finalizeFunction
});

In the present context, the value of the ‘key’ is the field ‘quesId’. Documents are grouped together on the basis of this key. The initial values for the parameters ‘count’ and ‘totalRating’ are set to zero. Besides these, two functions are declared and defined in the query. The function reduce totals the value of the ‘rating’ and saves it in ‘totalRating’. In addition to this, it also maintains the count of documents processed.

On the other hand, the function ‘finalize’ determines the average value of rating by dividing the value of ‘totalRating’ by the count.The execution of this query returns an array containing different ‘quesId’, which represents the different groups and the corresponding average rating for each of these groups.

Hope this will help.

Thanks,
Sakshi Tyagi
sakshi@intelligrape.com

 
1.GString: A GString is just like a normal String, except that it evaluates expression that are embedded with in string in the form ${..}.

String demo="Brother"
String doubleQuotes= "Hello ${demo}"
println doubleQuotes   //Output:Hello Brother

String slashy= /Hello ${demo}/
println slashy   //Output:Hello Brother

String dollarSlashy= $/Hello ${demo}/$
println dollarSlashy   //Output:Hello Brother

2.Single Quote:Groovy Treats a String created using single quotes as a pure literal.

String demo="World"
println 'Hello "${demo}"'   //Output: Hello "${demo}"

//To expand an expression Groovy uses double quotes, slashy and dollar slashy.

String multiLine='''With three  Single Quotes
In Groovy we can write
Multi-Line-String'''

3.Double Quotes:These are often used to define String expression.

int value=12
println "He bought ${value} egg "   //Output: He bought 12 egg

println "He paid \$${value} for that"   //Output: He paid $12 for that

//I have used the escape  character to print $ symbol since groovy uses that for embedding expressions.you don't have to escape $ if you use slashes, as you'll see soon.

String multiLine="""With three  Double Quotes
In Groovy we can write
Multi-Line-String"""

4.Slashy:These are often used for regular expression.

int value=12
String demo=/he paid $${value} for that/
println demo   //Output: he paid $12 for that

//Look here we don't have to escape $ symbol

String multiLine=/With slashy string
In Groovy we can write
Multi-Line-String/

5.Dollar Slashy:It is almost same as slashy string but with slightly different escaping rules .The biggest advantage of this is that we don’t even have to escape slash(‘/’) which results in a much cleaner regular expressions but you can use ‘$$’ to escape a ‘$’ or ‘$/’ to escape a slash if needed.

int value=12
String demo=$/he paid $ ${value} for one orange/$
println demo   // Output :he paid $ 12 for one orange

String demo1=$/he paid $$ ${value} for one orange/$
println demo1   // Output: he paid $ 12 for one orange

String demo2=$/Here evaluation will not take place $${value}, as we have escaped $ with $ /$
println demo2  
// Output: Here evaluation will not take place ${value}, as we have escaped $ with $

String demo3=$/what would you like to have tea/coffee/$
println demo3   //Output:what would you like to have tea/coffee

String demo4=$/what would you like to have tea$/coffee/$
println demo4   //Output:what would you like to have tea/coffee

//you can see that we can have a much cleaner Regex using dollar-slashy string.

String multiLine=$/With dollar-slashy string
In Groovy we can write
Multi-Line-String/$

I hope it helps, feel free to ask if you have any queries

First of all create your email template test.html under following directory.

app\locale\en_US\template\email. Where en_US is your default language pack. You can replace it with your own.

<!--@subject Custom Email for {{var customVariable}} @-->
<!--@vars
{"store url=\"\"":"Store Url",
"var logo_url":"Email Logo Image Url",
"var logo_alt":"Email Logo Image Alt",
}
@-->
<!--@styles
body,td { color:#2f2f2f; font:11px/1.35em Verdana, Arial, Helvetica, sans-serif; }
@-->
<body style="background:#F6F6F6; font-family:Verdana, Arial, Helvetica, sans-serif; font-size:12px; margin:0; padding:0;">
<div style="background:#F6F6F6; font-family:Verdana, Arial, Helvetica, sans-serif; font-size:12px; margin:0; padding:0;">
Hello {{var custName}}<br>
Thank you. Your logo path is {{var logo_url}}
</div>
</body>

<!–@subject : In this tag you can define subject line of your email.
<!–@vars : In vars section you can define your custom variable.
<!–@styles : In this tag section you can add custom style for your email template.
{{var custName}} : By using {{var custName}} you can add your custom variable in your email template.

Now add following code in your module’s config.xml file’s global node.

<template>
<email>
<test_email_template">
<label>Test Email</label>
<file>test.html</file>
<type>html</type>
</test_email_template>
</email>
</template>

Now clear magento cache and go to admin > Transactional Email > Add New Template. From here you can load your cuatom email template

Add the following code in your controller’s action from where you want to send your email.

<?php
$templateId = 25 //your email template id;
$sender = Array('name' => 'Sender's Name',
'email' => 'test@test.com');
//recepient
$email = 'abc@test.com';
$emaiName = 'Sender's Name';
$vars = Array();
$vars = Array('customVariable'=>$yourCustomVarialbe,
);*/
$storeId = Mage::app()->getStore()->getId();
$translate = Mage::getSingleton('core/translate');
Mage::getModel('core/email_template')
->sendTransactional($templateId, $sender, $email, $emailName, $vars, $storeId);
$translate->setTranslateInline(true);
?>

That’s it. Hope this will help you

Regards,
Amatya Trivedi
amatya@intelligrape.com

RewriteEngine On
RewriteCond %{SERVER_PORT} 80 
RewriteRule ^your-page-url/?$ https://%{HTTP_HOST}/your-page-url [R,L]

Now flush the cache and check.

Regards,
Amatya Trivedi
amatya@intelligrape.com

You can clone the shell script from git@github.com:manvendrasinghig/brightness.git using the standard git clone url command from a terminal.

Manvendra Singh
manvendra@intelligrape.com