Kendo UI Templates use a simple templating syntax we call "hash templates."

Hey, Telerik~ A quick word to the wise: It's probably worth including a link to where you actually explain that syntax everywhere you have a template property in your examples.

The info at their API docs for column templates is okay, but not great. The info at their templating explanation is pretty crucial for you to understand live examples of customizing grid display.

The four grid column template/rendering formats

Let's quickly list the different ways to produce column names and values.

1. Column name and value spit directly into the column.
   • columns: [ "id", "field1", "field2" ]
2. Change the title to whatever you want.
   • columns: [ "id", { title: "Whatever I want", field: "field1" } ]
3. Use a Telerik template.
   • { title: "File Preview", template: '<img src="#:field3#" alt="Thumbnail for asset id \\##:id#"" />' },
   • This is a little messier than the others. Note the "hash template" format.
   • You put whatever column value you want after the #:, sort of like a Razor template.
   • Then close with another #.
   • To escape a "real" #, you can use \\#, an escaped escape char (\), then the #.
   • Again, their full docs on templating are here.
4. Use a javascript function.
   • template: function(dataItem) { return "<strong>" + kendo.htmlEncode(dataItem.name) + "</strong>"; }
   • Note here that dataItem is just whatever's on the row.
   • There are no built-in properties I can find other than dirty and uid.
   • dirty is a boolean if the value's been changed, I assume.
   • uid is a GUID.
     • Honestly, I'm not sure where uid comes from, other that that's it's obviously Telerik.
     • That is, uid is not in my JSON payload.
   • NOTE: Functions don't work for title.
     • Blows up at a replace call.
     • From the telerik minimized code:
       • f.title&&(e+=i.attr("title")+'="'+f.title.replace(/'/g,"'")+'" '),

Quick critique ;^)

Though I don't mind overloading parameters, at some point, it seems like you should've sunk your time into one or the other -- either allow functions or develop some crazy templating system. Personally, I prefer number four over three, as it doesn't require any Telerik-specific knowledge.

Telerik has an interesting way of creating sort of simplest case examples, but would benefit from a sort of kitchen sink style demo that slowly builds on itself of the grid. "Here's a grid with a straight column, a column with a formatter, and a column with template." You know, like this:

Composite example with each column renderer type

$(document).ready(function() {
    $("#gridTest").kendoGrid({

        //==========================================
        // Methods to produce columns.
        //==========================================
        columns: [
        // 1. Raw column name and value.
            "id",
        // 2. Change title, raw value.
            { title: "Whatever I want", field: "field1" },
        // 3. Use a Telerik template for value.
            {
                title: "File Preview", 
                template: '<img src="#:field2#" alt="Thumbnail for \\##:id#"" />' 
            },
        // 4. Use a javascript function for value.       
            {
                title: "Test function",
                template: function(dataItem)    {
                    return "<strong>" 
                        + kendo.htmlEncode(dataItem.field3) 
                        + "</strong>";
                }
            }
        ],
        //==========================================
        // End of column fun.
        //==========================================

        filterable: true,
        sortable: true,
        pageable: true,
        height: 550,

        dataSource: {
            // http://docs.telerik.com/kendo-ui/api/javascript/data/datasource#configuration-transport.read
            transport: {
                read: {
                    url: "./GetInfo",
                    dataType: "json",
                    contentType: "application/json",
                    type:"POST"
                },
                parameterMap: function (data, type) {
                    // Removed this for now, but it's needed; see below.
                }
            },
            schema: {
                model: { id: "id" }
            },
            pageSize: 20,
            serverPaging: true,
            serverFiltering: true,
            serverSorting: true
        },

        lastProp: null
    });
});

See, Telerik? Was that so hard? (They have so many examples this is probably in there somewhere, but it sure isn't where I'd expect it: At the top of columns.template explanation.

Just for fun, let's also return to the parameterMap function. The way Telerik grids send parameters for information requests is sort of strange. If you're pushing something up to a .NET MVC controller, you might not want stuff that looks like sort[0][field] before it's turned into a request. That's kind of hard to deserialize.

Instead, the answer is that you deserialize it yourself, on the client, in JavaScript, then reserialize into something easy to hand to your controller. I'm going to reorganize everything into a params object that I throw into a JSON string and return from parameterMap. My new string is what'll get passed back up.

parameterMap: function (data, type) {
    // By default, the grid sends a somewhat peculiar set of parameters with requests
    // that do server-side sorting. For example the sort { field: "age", dir: "desc" }
    // is sent (by default) as:
    //      sort[0][field]: age
    //      sort[0][dir]: desc
    // The parameterMap function allows us to send it up in a different format.
    // http://docs.telerik.com/kendo-ui/api/javascript/data/datasource#methods-sort
    var params = {
        skip: data.skip,
        take: data.take,
        page: data.page
    };

    if (data.sort)  {
        params.sort = {
            field: data.sort[0].field,
            dir: data.sort[0].dir
        };
    }
    // console.log wrapper >>> utils.logit("Param type: " + type);
    return JSON.stringify();
}

Kinda ugly default, but a reasonable way to customize things.

Labels: javascript, noteToSelf, telerik

type char(2)
 

Object type:
AF = Aggregate function (CLR)
C = CHECK constraint
D = DEFAULT (constraint or stand-alone)
F = FOREIGN KEY constraint
FN = SQL scalar function
FS = Assembly (CLR) scalar-function
FT = Assembly (CLR) table-valued function
IF = SQL inline table-valued function
IT = Internal table
P = SQL Stored Procedure
PC = Assembly (CLR) stored-procedure
PG = Plan guide
PK = PRIMARY KEY constraint
R = Rule (old-style, stand-alone)
RF = Replication-filter-procedure
S = System base table
SN = Synonym
SO = Sequence object 

Applies to: SQL Server 2012 through SQL Server 2016.
SQ = Service queue
TA = Assembly (CLR) DML trigger
TF = SQL table-valued-function
TR = SQL DML trigger
TT = Table type
U = Table (user-defined)
UQ = UNIQUE constraint
V = View
X = Extended stored procedure

IF OBJECT_ID('TableName', 'U') IS NOT NULL
DROP TABLE TableName;

Labels: noteToSelf, SQL, SQL Server, t-sql

Why should you use DateTimeUTC and not DateTime in your SaaS systems? 4guysFromRolla actually has a pretty good answer from 2007:

The primary advantage of storing date/time values in UTC is that it makes the data transportable. To see what I mean, imagine that following scenario: you have an eCommerce website that is being hosted in a web server located in the Pacific time zone (UTC -8) and this application stores the date and time orders were placed in server time. Say a user, Bob, makes an order on August 1, 2007 at 9:00 AM UTC -8. After many months of phenomenal growth, you decide to switch to a larger web hosting company, one on the east coast where the time zone is UTC -5. Since the date/time is stored in server time, Bob's previous order still shows that it was made on August 1 2007 at 9:00 AM. But since we are now in UTC -5, it is as if Bob's order was made three hours earlier than it really was (since when it was 9:00 AM on August 1, 2007 in the west coast it was really 12:00 noon on the east coast).

One way around this, you might contend, is to execute a SQL query that adds three hours to the order date for all records in the table. Something like:

UPDATE Orders SET

OrderDate = DATEADD(hh, 3, OrderDate)

And such an approach would suffice... for this situation. But imagine that you moved to a web hosting company situated in the US state of Arizona, where daylight savings is not observed. E[s]p. Now you would have to write a more complex UPDATE statement that adjusted the hours based on whether the order date fell within daylight savings. Ick.

...

Things like daylight savings further complicate working with dates and times, but UTC does not observe any time zone, simplifying things a tiny bit. [emph mine -mfn]

To make a long story short, you have two choices:

• Use DataTimeUTC and use built-in converters to get "local" time, usually on the client
• Pick another "native" time zone for your system, and prepare to maintain your own converters

Seems an easy enough choice to me.

Labels: .NET, coding, dates, SQL

Editor's Note: CBS has an investment in FanDuel of less than 1 percent of that company's value.

• The owners of the teams who are being bet (or whose players performances determine who wins a game, whichever way you look at it)
• The teams' broadcasters (Fox) 
• I'd add ESPN to this. So many ads, even native reads on Mike & Mike, who wouldn't stop saying that these things were games of skill, and how much they enjoyed playing. If I have to hear one more stupid comparison to state lotteries or poker games... I'd like to hear how often the hosts played & what they won/lost.
• The news outlets that both broadcast and report on them (Yahoo and CBS)
• The banks that provide payment to them (PayPal)

Labels: hats of money, Other Stuff

Labels: coding, goals, JSLint, stackoverflow, style

Labels: apple fail, fail, iTunes, qa, testing

From here:

SOLUTION: in Windows 7 [and 8, as it turns out -mfn], press and hold Shift and right click on the grouped icon that you want to open all of it's grouped windows in a cascade arrangement, then click on Cascade . All the windows of this particular program will open in cascade exactly as in XP.

Wow. Yes please. I used to use the right-click shortcut to cascade all the windows, but didn't realize you could do it one application at a time, I don't think. I often leave open too many browser windows, and it's nice to bring them all to the front where they're easily eyeballed before shutting them out.

Labels: noteToSelf, windows

document.body.insertBefore(
    document.createElement("test1"), document.body.childNodes[0]
);

That could've been easier. I think. Bottom line is that you're taking the parent node, and inserting a new node (first parameter) before the existing (second param). Here, of course, I'm doing it to the body. Sub document.body with the node o' your choice.

EDIT: So here's a slightly nicer way of inserting html, since the above won't actually parse HTML in the string...

function insertAsFirstChild(strHtml, nodeWithChildren)    {
    // If strHtml isn't wrapped in tags, we probably want to put into
    // a span so that we can accept html. CreateTextElement would push
    // out the text as is, showing markup in the page.
    var newSpan, strTag, strEndTag;

    newSpan = document.createElement("span");
    if (!nodeWithChildren)  {
        nodeWithChildren = document.body;
    }

    if (
        0 === strHtml.indexOf("<")
        && strHtml.length - 1 === strHtml.lastIndexOf(">")
        && strHtml.indexOf("</" > -1)
    ) {
        strTag = strHtml.substring(1, strHtml.indexOf(">"));
        strEndTag = strHtml.slice(strHtml.lastIndexOf("</")+2, -1);

        if (strTag && strTag === strEndTag)   {
            newSpan = document.createElement(strTag);
            strHtml = strHtml.substring(strHtml.indexOf(">")+1, strHtml.lastIndexOf("</"));
        }
    }

    newSpan.innerHTML = strHtml;
    nodeWithChildren.insertBefore(newSpan, nodeWithChildren.childNodes[0]);
}

Labels: javascript, noteToSelf

Labels: git, tfs