');
html = this.renderHeader(html);
html = this.renderBody(html);
html = this.renderFooter(html);
html.push('
');
this.settings.container.innerHTML = html.join("\n");
this.applyListeners();
this.clearRenderers();
this.renderEvent.fire();
},
/**
* creates html string representing navigation and month name
* @method renderHeader
* @param {Array} html array of html strings which will later be inserted into this.container via innerHTML
* @return {Array} returns the array passed in
*/
renderHeader:function(html){
var startDate = this._startDate;
var currentMonth = startDate.getMonth(),
currentYear = startDate.getFullYear(),
self = this;
html.push('');
return html;
},
/**
* creates html string representing the day headings and dates, using the built-in and renderers along with any
* custom defined renders (see addRenderer)
* @method renderBody
* @param {Array} html array of html strings which will later be inserted into this.container via innerHTML
* @return {Array} returns the array passed in
*/
renderBody:function(html) {
var startDate = this._startDate;
var currentMonth = startDate.getMonth();
var currentYear = startDate.getFullYear();
var currentDay = new Date(currentYear,currentMonth,1).getDay();
var week,day,cell,i,j,renderers;
html.push('');
// create day headers
for (i = 0; i < 7; i++){
html.push('
');
html.push( this.getCopy("WEEKDAYS_SHORT." + i));
html.push('
');
}
html.push('
');
var preMonthDays = this._startDate.getDay();
var workingDate = new Date(this._startDate.getFullYear(),this._startDate.getMonth(),this._startDate.getDate())
workingDate = CalUtils.addDays(-preMonthDays,workingDate);
var tempContainer = document.createElement("div");
// todo: make hideBlankWeeks && isBlankWeek work
var hideBlankWeeks =false, isBlankWeek = false;
for(week = 0; week < 6; week++){
if(hideBlankWeeks && isBlankWeek){
break;
}
for(day = 0; day < 7; day++){
tempContainer.innerHTML = "";
cell = document.createElement("div");
yuiDom.addClass(cell,"day");
renderers = [];
// determine which rendering methods should be applied
if(workingDate.getMonth() != this._startDate.getMonth()){
renderers.push(Calendar.renderOutOfMonth);
}else{
cell.setAttribute("date", CalUtils.dateToSystemFormat(workingDate));
// rendertypes:date,range,weekday (day/dayOfWeek)
for(i = 0; i < this._renderStack.length; i++){
switch(this._renderStack[i].type){
case Calendar.RENDER_TYPE_DATE:
if(workingDate.getTime() == this._renderStack[i].value.getTime()){
renderers.push(this._renderStack[i].method);
this._renderStack.splice(i,1);
}
break;
case Calendar.RENDER_TYPE_RANGE:
if(workingDate >= this._renderStack[i].value[0] && workingDate <= this._renderStack[i].value[1]){
renderers.push(this._renderStack[i].method);
if(workingDate >= this._renderStack[i].value[1]){
this._renderStack.splice(i,1);
}
}
break;
case Calendar.RENDER_TYPE_WEEKDAY:
if(workingDate.getDay() == this._renderStack[i].value){
renderers.push(this._renderStack[i].method);
}
break;
}
}
if( (this.settings.minDate && workingDate < this.settings.minDate )
|| (this.settings.maxDate && workingDate > this.settings.maxDate )){
// out of month
renderers.push(Calendar.renderOutOfRange);
}else{
// render default
renderers.push(Calendar.renderDefault);
}
}
// if needed other renderers could go here - lef,top,bottom, etc
for(j = 0; j < renderers.length; j++){
if(renderers[j].call(this,workingDate,cell) === Calendar.STOP_RENDERING){
break;
}
}
tempContainer.appendChild(cell);
html.push(tempContainer.innerHTML);
CalUtils.addDays(1,workingDate);
}
html.push('
');
}
html.push('
');
return html;
},
/**
* placeholder method, no footer created by default
* @method renderBody
* @param {Array} html array of html strings which will later be inserted into this.container via innerHTML
* @return {Array} returns the array passed in
*/
renderFooter:function(html){
return html;
},
/**
* provides access to internal start date (always the first of the month)
* @method getStartDate
* @return {Date}
*/
getStartDate:function(){
return this._startDate;
},
/**
* used to change start date. The first of month will be direved from the date passed in and will become the start date
* @method setStartDate
* @return {Date}
*/
setStartDate:function(date){
this._startDate = CalUtils.setFirstOfMonth(date,true);
},
/**
* use to change start month and render the calendar
* @method changeMonth
* @param {Int} byMonths number of months to change by. use negative number for previous
*/
changeMonth:function(byMonths){
this._startDate.setMonth(this._startDate.getMonth() + byMonths);
this.render();
},
/**
* shortcut to changeMonth, advances Calendar one month forward
* @method showNext
*/
showNext:function(){
this.changeMonth(1);
},
/**
* shortcut to changeMonth, shows previous Calendar month
* @method showPrevious
*/
showPrevious:function(){
this.changeMonth(-1);
},
/**
* use to add render methods
* @method addRenderer
* @param {String} type One of: Calendar.RENDER_TYPE_DATE, Calendar.RENDER_TYPE_RANGE, Calendar.RENDER_TYPE_WEEKDAY
* @param {Date | Array | Int} value For type "date", value is Date; for type "range", type is array of Date [Date,Daate];
* for type "weekday", value will Int representing day of week (see contstants)
* @param {Function} method can be one of the provided methods, or a custom method which will
* be passed Date and Cell are passed as params to method
*/
addRenderer:function(type,value,method){
this._renderStack.push( { type:type, value:value, method:method } );
},
/**
* each time render is called, all renderers are removed from the stack
* @method clearRenderers
*/
// todo: consider making this private
clearRenderers:function(){
this._renderStack.length = 0;
}
};
// namespace
YAHOO.namespace("SW.widget.Calendar");
yuiLang.augmentProto(Calendar,SW.widget.Calendar.CopyCommon);
SW.widget.Calendar.Calendar = Calendar;
})();
(function(){
var yuiDom = YAHOO.util.Dom,
yuiEvent = YAHOO.util.Event,
yuiLang = YAHOO.lang,
yuiEnv = YAHOO.env,
customEvent = YAHOO.util.CustomEvent,
Html = SW.tools.Html,
Calendar = SW.widget.Calendar.Calendar,
CalUtils = SW.widget.Calendar.Utils;
var DEFAULT_SETTINGS = {
monthsToDisplay:2,
maxRange:31,
displayLimit:549,
limitNavigation:true,
minDate:CalUtils.getToday(),
maxDate:null
}
/*
optional config params:
container
trigger
*/
function CalendarGroup(settings){
CalendarGroup.INSTANCES.push(this);
this._state = Calendar.STATE_UNSELECTED;
this.errorArray = [];
this.calendarDivMonth = [];
this.initSettings(settings);
this.initCopy(settings.copy);
this.initEvents();
// ensure we do not have a bad number for monthsToDisplay
if(isNaN(this.settings.monthsToDisplay)){
this.settings.monthsToDisplay = 2;
}
if(!this.settings.maxDate && this.settings.displayLimit > 0){
this.settings.maxDate = CalUtils.addDays(this.settings.displayLimit, new Date());
}
if(this.settings.minDate){
this.firstOfStartMonth = new Date(this.settings.minDate.getFullYear(), this.settings.minDate.getMonth(), 1)
}
if(this.settings.maxDate){
this.lastOfEndMonth = CalUtils.setLastOfMonth(this.settings.maxDate,true);
}
/*todo old code passed a function reference and assigned value for rangeStart and checkout*/
// perhaps listening to beforeShowEvent from StayCal will solve this? Allowing rangeStart/End here is fine regardless
if(this.settings.rangeStartDate && this.settings.rangeEndDate){
this.setRangeDates(this.settings.rangeStartDate,this.settings.rangeEndDate);
}else if(this.settings.rangeStartDate){
this.setRangeStartDate(this.settings.rangeStartDate);
}else if(this.settings.rangeEndDate){
this.setRangeEndDate(this.settings.rangeEndDate);
}
this.setStartDate(this.settings.calStartDate);
}
CalendarGroup.INSTANCES = [];
CalendarGroup.prototype = {
/* privates */
_TYPE:"CalendarGroup",
_initialized:false,
handleReset:function(e){
yuiEvent.preventDefault(e);
this.reset();
},
handleResetRangeStart:function(e){
yuiEvent.preventDefault(e);
this.resetRangeStartDate();
},
handleResetRangeEnd:function(e){
yuiEvent.preventDefault(e);
this.resetRangeEndDate();
},
initialize:function(){
if(this._initialized) { return false; }
this._initialized = true;
this.createFramework();
this.initCalendars();
this.initHandlers();
this.render();
return true;
},
initCalendars:function(){
var x,calendar,startDate,showNext,showPrevious;
this.calendars = [];
for(x = 0; x < this.settings.monthsToDisplay; x++ ){
startDate = new Date(this.calStartDate);
startDate.setMonth(startDate.getMonth()+x);
showNext = (x == this.settings.monthsToDisplay -1);
showPrevious = (x == 0);
calendar = new Calendar({
container:this.calendarDivMonth[x],
startDate:startDate,
today:this.settings.minDate,
minDate:this.settings.minDate,
maxDate:this.settings.maxDate,
hideNext:!showNext,
hidePrevious:!showPrevious,
copy:this.copy
});
calendar.initialize();
this.calendars.push(calendar);
}
},
initEvents:function(){
this.hoverOverEvent = new customEvent("hoverOverEvent",null,false,customEvent.FLAT);
this.hoverOutEvent = new customEvent("hoverOutEvent",null,false,customEvent.FLAT);
this.beforeSelectEvent = new customEvent("beforeSelectEvent",null,false,customEvent.FLAT);
this.selectEvent = new customEvent("selectEvent",null,false,customEvent.FLAT);
this.previousEvent = new customEvent("previousEvent",null,false,customEvent.FLAT);
this.nextEvent = new customEvent("nextEvent",null,false,customEvent.FLAT);
this.beforeRenderEvent = new customEvent("beforeRenderEvent",null,false,customEvent.FLAT);
this.renderEvent = new customEvent("renderEvent",null,false,customEvent.FLAT);
},
initHandlers:function(){
var i;
var self = this;
// proxy most Calendar events
for(i = 0; i < this.calendars.length; i++){
this.calendars[i].beforeSelectEvent.subscribe(function(param){
return self.beforeSelectEvent.fire(param);
});
this.calendars[i].selectEvent.subscribe(function(param){
return self.selectEvent.fire(param);
});
this.calendars[i].previousEvent.subscribe(function(param){
return self.previousEvent.fire(param);
});
this.calendars[i].nextEvent.subscribe(function(param){
return self.nextEvent.fire(param);
});
this.calendars[i].hoverOverEvent.subscribe(function(param){
return self.hoverOverEvent.fire(param);
});
this.calendars[i].hoverOutEvent.subscribe(function(param){
return self.hoverOutEvent.fire(param);
});
}
},
initSettings:function(config){
var prop,
settings = this.settings = {};
// get defaults
for(prop in DEFAULT_SETTINGS){
if(yuiLang.hasOwnProperty(DEFAULT_SETTINGS,prop)){
settings[prop] = DEFAULT_SETTINGS[prop];
}
}
// override and set additional
for(prop in config){
if(yuiLang.hasOwnProperty(config,prop)){
settings[prop] = config[prop];
}
}
},
setRangeDates:function(stateDate,endDate){
var s = stateDate,
e = endDate;
if(stateDate > endDate){
s = endDate;
e = stateDate;
}
this.rangeStartDate = s;
this.rangeEndDate = e;
this._updateState();
},
setRangeStartDate:function(date){
this.rangeStartDate = date;
this._updateState();
},
setRangeEndDate:function(date){
this.rangeEndDate = date;
this._updateState();
},
setStartDate:function(date){
date = date || this.getDefaultStartDate();
date = CalUtils.setFirstOfMonth(date,true);
if( (this.settings.minDate && date < this.firstOfStartMonth)
|| (this.settings.maxDate && date > this.lastOfEndMonth) ) {
date = this.firstOfStartMonth;
}
this.calStartDate = date;
},
// get calendar start date based on rangeStart and rangeEnd
getDefaultStartDate:function(){
return (this.rangeStartDate) ? new Date(this.rangeStartDate.getFullYear(),this.rangeStartDate.getMonth(), 1) : this.firstOfStartMonth;
},
selectDay:function(params){
if(yuiDom.hasClass(params.cell,"availableRangeStart")){
if(params.date != this.rangeStartDate){
if(this.rangeStartDate && !this.rangeEndDate){
this.setRangeDates(params.date,this.rangeStartDate);
}else{
this.setRangeStartDate(params.date);
}
this.render();
}
}else if(yuiDom.hasClass(params.cell,"availableRangeEnd")){
if(params.date != this.rangeEndDate){
if(this.rangeEndDate && !this.rangeStartDate){
this.setRangeDates(params.date,this.rangeEndDate);
}else{
this.setRangeEndDate(params.date);
}
this.render();
}
}
},
/*
whenever rangeStart/rangeEnd dates are changed, state needs to updated.
setRangeStartDate/Out methods use this internally.
*/
_updateState:function(){
if(this.rangeStartDate && this.rangeEndDate){
this._state = Calendar.STATE_RANGE_SELECTED;
}else if(!this.rangeStartDate && !this.rangeEndDate){
this._state = Calendar.STATE_UNSELECTED;
}else if(this.rangeStartDate){
this._state = Calendar.STATE_START_SELECTED;
}else{
this._state = Calendar.STATE_END_SELECTED;
}
},
getState:function(){
return this._state;
},
// proxy prev/next methods...
showNext:function(){
this.changeMonth(1);
},
showPrevious:function(){
this.changeMonth(-1);
},
changeMonth:function(byMonths){
var firstCalDate = this.calendars[0].getStartDate(),
newStartDate;
if(this.settings.limitNavigation){
if(byMonths < 0){
newStartDate = new Date(firstCalDate.getFullYear(),firstCalDate.getMonth()+byMonths,firstCalDate.getDate());
if(newStartDate < this.firstOfStartMonth){
return false;
}
}else{
newStartDate = new Date(firstCalDate.getFullYear(),firstCalDate.getMonth()+byMonths+this.settings.monthsToDisplay-1,firstCalDate.getDate());
if(newStartDate > this.lastOfEndMonth){
return false;
}
}
}
function changeMonth(cal){
cal.changeMonth(byMonths);
}
// since we are not listening to Calendar's render events, need to fire these here
// other possibility - have Calendar's changeMonth only set the date but not render - then call render here
if(! this.beforeRenderEvent.fire()){ return; }
this.calendars.forEach(changeMonth);
this.renderEvent.fire()
},
reset:function(){
this.setRangeStartDate(null);
this.setRangeEndDate(null);
this.render();
},
resetRangeStartDate:function(){
this.setRangeStartDate(null);
this.render();
},
resetRangeEndDate:function(){
this.setRangeEndDate(null);
this.render();
},
addRenderer:function(type,value,method){
function processCal(cal){
cal.addRenderer(type,value,method);
}
this.calendars.forEach(processCal);
},
render:function(){
if(! this.beforeRenderEvent.fire()){ return; }
this.renderHeader();
this.renderBody();
this.renderFooter();
this.renderErrors();
this.renderEvent.fire();
},
renderHeader:function(){
// override in subclass if header may change on each render
},
renderBody:function(){
function processCal(cal){
cal.render();
}
this.calendars.forEach(processCal);
},
renderFooter:function(){
// override in subclass if footer may change on each render
},
createFramework:function(){
var head,body,foot;
this.container = document.createElement("div");
yuiDom.addClass(this.container,"calendarContainer");
var innerContainer = document.createElement("div");
yuiDom.addClass(innerContainer,"calendarContainerInner");
this.container.appendChild(innerContainer);
if(yuiEnv.ua.ie && yuiEnv.ua.ie <= 6){
//create the iframe to sit behind the layer - workaround for IE and select boxes
var calenderIframe = document.createElement("iframe");
calenderIframe.width = 0;
calenderIframe.height = 0;
calenderIframe.src = "/common/blank.jsp";
yuiDom.setStyle(calenderIframe, "zIndex", "99998");
this.container.appendChild(calenderIframe);
}
head = document.createElement("div");
body = document.createElement("div");
foot = document.createElement("div");
this.head = head;
this.body = body;
this.foot = foot;
yuiDom.addClass(head,"calendarHeader");
yuiDom.addClass(body,"calendarBody");
yuiDom.addClass(foot,"calendarFooter");
this.createHeader(head);
this.createBody(body);
this.createFooter(foot);
innerContainer.appendChild(head);
innerContainer.appendChild(body);
innerContainer.appendChild(foot);
Html.appendClearDiv(innerContainer);
var parentNode = this.settings.container;
if(!parentNode){
parentNode = document.body;
this.settings.container = this.container;
}
parentNode.appendChild(this.container);
yuiEvent.addListener(this.container,"click",yuiEvent.stopPropagation, this,true);
},
// placeholder, likely overridden in subclass
createHeader:function(container){
},
// createBody should not be overridden in a subclass. if it is, it must setup calendarDivMonth
createBody:function(container){
var innerContainer = document.createElement("div");
for(var i = 0; i < this.settings.monthsToDisplay; i++) {
var calEl = document.createElement("div");
innerContainer.appendChild(calEl);
this.calendarDivMonth[i] = calEl;
}
yuiDom.addClass(this.calendarDivMonth[0],"firstMonth");
yuiDom.addClass(this.calendarDivMonth[this.calendarDivMonth.length - 1],"lastMonth");
container.appendChild(innerContainer);
// clear div
Html.appendClearDiv(container);
},
// placeholder, likely overridden in subclass
createFooter:function(container){
}
};
// namespace
YAHOO.namespace("SW.widget.Calendar");
yuiLang.augmentProto(CalendarGroup,SW.widget.Calendar.CopyCommon);
SW.widget.Calendar.Group = CalendarGroup;
})();
(function(){
var yuiEvent = YAHOO.util.Event,
yuiDom = YAHOO.util.Dom,
yuiLang = YAHOO.lang,
customEvent = YAHOO.util.CustomEvent,
Html = SW.tools.Html,
Calendar = SW.widget.Calendar.Calendar,
SuperClass = SW.widget.Calendar.Group.prototype,
CalUtils = SW.widget.Calendar.Utils,
widget = SW.widget;
function StayCalendar(config){
StayCalendar.INSTANCES.push(this);
SuperClass.constructor.call(this, config);
this.triggers = {};
if(this.settings.trigger){
this.triggers.show = this.settings.trigger;
}
}
StayCalendar.INSTANCES = [];
yuiLang.extend(StayCalendar, widget.Calendar.Group,{
_TYPE:"StayCalendar",
_CONTAINER_CLASS:"stayCalendar",
_isShowing:false,
showHover:function(param){
yuiDom.addClass(param.cell,"hover");
var el = null,coords;
if(yuiDom.hasClass(param.cell,"availableRangeStart") && !yuiDom.hasClass(param.cell,"rangeStart")){
el = this._rangeStartMessage;
}else if (yuiDom.hasClass(param.cell,"availableRangeEnd") && !yuiDom.hasClass(param.cell,"rangeEnd")){
el = this._rangeEndMessage;
}
if(el){
coords = yuiEvent.getXY(param.event);
coords[0] += 15;
coords[1] += 10;
yuiDom.addClass(el,"show");
yuiDom.setXY(el,coords,true);
}
},
hideHover:function(param){
yuiDom.removeClass(this._rangeStartMessage,"show");
yuiDom.removeClass(this._rangeEndMessage,"show");
if(param && param.cell){
yuiDom.removeClass(param.cell,"hover");
}
},
initialize:function(){
// ensure bad dates aren't passed in
if(!this.validateCalendar()){
this.setRangeDates(null, null);
this.setStartDate(null);
};
if(!SuperClass.initialize.call(this)) { return false; }
},
initEvents:function(){
SuperClass.initEvents.call(this);
this.beforeShowEvent = new customEvent("beforeShowEvent",null,false,customEvent.FLAT);
this.showEvent = new customEvent("showEvent",null,false,customEvent.FLAT);
this.beforeHideEvent = new customEvent("beforeHideEvent",null,false,customEvent.FLAT);
this.hideEvent = new customEvent("hideEvent",null,false,customEvent.FLAT);
this.beforeSubmitEvent = new customEvent("beforeSubmitEvent",null,false,customEvent.FLAT);
this.submitEvent = new customEvent("submitEvent",null,false,customEvent.FLAT);
},
initHandlers:function(){
SuperClass.initHandlers.call(this);
this.beforeSelectEvent.subscribe(function(params){
var errors = this.validateSelectedDate(params);
this.renderErrors();
return errors;
},this,true);
this.selectEvent.subscribe(function(params){
this.hideHover();
this.selectDay(params);
},this,true);
// subclasses may need to unsubscribe these methods in order to perform animations
this.showEvent.subscribe(this.simpleShow,this,true);
this.hideEvent.subscribe(this.simpleHide,this,true);
this.hoverOverEvent.subscribe(this.showHover,this,true);
this.hoverOutEvent.subscribe(this.hideHover,this,true);
this.previousEvent.subscribe(this.showPrevious,this,true);
this.nextEvent.subscribe(this.showNext,this,true);
this.beforeRenderEvent.subscribe(this.setRenderers,this,true);
this.beforeShowEvent.subscribe(this.setPosition,this,true);
},
simpleShow:function(){
yuiDom.addClass(this.container, "show");
},
simpleHide:function(){
yuiDom.removeClass(this.container, "show");
},
isShowing:function(){
return this._isShowing;
},
show:function(){
if(this.isShowing()){ return false; }
if(!this._initialized){
this.initialize();
}
if(this.beforeShowEvent.fire()){
this._isShowing = true;
this.showEvent.fire();
}
},
hide:function(){
if(!this.isShowing()){ return false; }
if(this.beforeHideEvent.fire()){
this._isShowing = false;
this.hideEvent.fire();
}
},
submit:function(){
if(!this.beforeSubmitEvent.fire()){ return false; }
this.submitEvent.fire()
},
setRenderers:function(){
var tDate1,tDate2,tDate3,tDate4,daysBetween;
switch(this._state){
case Calendar.STATE_UNSELECTED:
// avail check in
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[this.settings.minDate,this.settings.maxDate],Calendar.renderAvailableRangeStart);
break;
case Calendar.STATE_START_SELECTED:
// check in
this.addRenderer(Calendar.RENDER_TYPE_DATE,this.rangeStartDate,Calendar.renderRangeStart);
// avail check in
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[this.settings.minDate,this.rangeStartDate],Calendar.renderAvailableRangeStart);
// unselected
tDate2 = new Date(this.rangeStartDate.getFullYear(),this.rangeStartDate.getMonth(),this.rangeStartDate.getDate());
tDate2 = CalUtils.addDays(-1,tDate2);
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[this.settings.minDate,tDate2],Calendar.renderUnselected);
// avail check out
tDate1 = new Date(this.rangeStartDate.getFullYear(),this.rangeStartDate.getMonth(),this.rangeStartDate.getDate());
tDate1 = CalUtils.addDays(1,tDate1);
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[tDate1,this.settings.maxDate],Calendar.renderAvailableRangeEnd);
break;
case Calendar.STATE_RANGE_SELECTED:
// check in/out
this.addRenderer(Calendar.RENDER_TYPE_DATE,this.rangeStartDate,Calendar.renderRangeStart);
this.addRenderer(Calendar.RENDER_TYPE_DATE,this.rangeEndDate,Calendar.renderRangeEnd);
// selected
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[this.rangeStartDate,this.rangeEndDate],Calendar.renderSelected);
// unselected
tDate3 = new Date(this.rangeStartDate.getFullYear(),this.rangeStartDate.getMonth(),this.rangeStartDate.getDate());
tDate3 = CalUtils.addDays(-1,tDate3);
tDate4 = new Date(this.rangeEndDate.getFullYear(),this.rangeEndDate.getMonth(),this.rangeEndDate.getDate());
tDate4 = CalUtils.addDays(1,tDate4);
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[this.settings.minDate,tDate3],Calendar.renderUnselected);
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[tDate4,this.settings.maxDate],Calendar.renderUnselected);
// avail check in
daysBetween = Math.round(Math.abs(this.rangeEndDate - this.rangeStartDate)/(1000 * 60 * 60 * 24)) - 1;
tDate1 = new Date(this.rangeStartDate.getFullYear(),this.rangeStartDate.getMonth(),this.rangeStartDate.getDate());
tDate1 = CalUtils.addDays(Math.floor(daysBetween/2),tDate1);
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[this.settings.minDate,tDate1],Calendar.renderAvailableRangeStart);
// avail check out
tDate2 = new Date(tDate1.getFullYear(),tDate1.getMonth(),tDate1.getDate());
tDate2 = CalUtils.addDays(1,tDate2);
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[tDate2,this.settings.maxDate],Calendar.renderAvailableRangeEnd);
break;
case Calendar.STATE_END_SELECTED:
// check out
this.addRenderer(Calendar.RENDER_TYPE_DATE,this.rangeEndDate,Calendar.renderRangeEnd);
// avail check in
tDate1 = new Date(this.rangeEndDate.getFullYear(),this.rangeEndDate.getMonth(),this.rangeEndDate.getDate());
tDate1 = CalUtils.addDays(-1,tDate1);
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[this.settings.minDate,tDate1],Calendar.renderAvailableRangeStart);
// avil checkout/unselected
tDate4 = new Date(this.rangeEndDate.getFullYear(),this.rangeEndDate.getMonth(),this.rangeEndDate.getDate());
tDate4 = CalUtils.addDays(1,tDate4);
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[tDate4,this.settings.maxDate],Calendar.renderUnselected);
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[tDate4,this.settings.maxDate],Calendar.renderAvailableRangeEnd);
break;
}
},
renderCloseButton: function(container) {
// create close button
var closeButton = document.createElement("div");
yuiDom.addClass(closeButton, "closeLink");
var closeAction = document.createElement("a");
closeAction.href = "javascript:void(0);";
yuiEvent.addListener(closeAction, "click", this.handleHide, this, true);
closeAction.title = this.getCopy("CLOSE");
closeAction.appendChild(document.createTextNode(this.getCopy("CLOSE")));
closeButton.appendChild(closeAction);
container.appendChild(closeButton);
this.triggers.hide = closeButton;
// console.log("render and set to triggers")
return closeButton;
},
renderFooter:function(){
var resetLink;
// submit text doesn't change so needs to be rendered the same on each step
this._menuElements.submitInstructions.innerHTML = this.getCopy("SUBMIT_INSTRUCTIONS");
if(this.rangeStartDate) {
this._menuElements.rangeStartInstructions.innerHTML = this.getCheckInCopy();
resetLink = document.createElement("a");
resetLink.innerHTML = this.getCopy("RANGE_START_RESET");
resetLink.href = "#";
yuiEvent.addListener(resetLink, "click", this.handleResetRangeStart, this, true);
this._menuElements.rangeStartInstructions.appendChild(resetLink);
yuiDom.removeClass(this._menuElements.rangeStartInstructions, "active");
yuiDom.addClass(this._menuElements.rangeEndInstructions, "active");
} else {
this._menuElements.rangeStartInstructions.innerHTML = this.getCopy("RANGE_START_INSTRUCTIONS");
yuiDom.addClass(this._menuElements.rangeStartInstructions, "active");
}
if(this.rangeEndDate) {
this._menuElements.rangeEndInstructions.innerHTML = this.getCheckOutCopy();
resetLink = document.createElement("a");
resetLink.innerHTML = this.getCopy("RANGE_END_RESET");
resetLink.href = "#";
yuiEvent.addListener(resetLink, "click", this.handleResetRangeEnd, this, true);
this._menuElements.rangeEndInstructions.appendChild(resetLink);
yuiDom.removeClass(this._menuElements.rangeEndInstructions, "active");
} else{
this._menuElements.rangeEndInstructions.innerHTML = this.getCopy("RANGE_END_INSTRUCTIONS");
}
if(this.rangeStartDate && this.rangeEndDate) {
yuiDom.addClass(this._menuElements.submitInstructions, "active"); // apply active class to check out div
this._menuElements.continueButton.innerHTML = this.getCopy("SUBMIT");
this._menuElements.submitInstructions.appendChild(this._menuElements.continueButtonContainer);
} else{
yuiDom.removeClass(this._menuElements.submitInstructions, "active"); // apply active class to check out div
if(this._menuElements.continueButtonContainer.parentNode == this._menuElements.submitInstructions) {
this._menuElements.submitInstructions.removeChild(this._menuElements.continueButtonContainer);
}
if(!this.rangeStartDate && !this.rangeEndDate) {
yuiDom.addClass(this._menuElements.rangeStartInstructions, "active"); // apply active class to check out div
yuiDom.removeClass(this._menuElements.rangeEndInstructions, "active");
}
}
},
getCheckInCopy:function(){
return this.getCopy("RANGE_START_PREFIX") + " - " + this.getLocaleFormattedDate(this.rangeStartDate);
},
getCheckOutCopy:function(){
return this.getCopy("RANGE_END_PREFIX") + " - " + this.getLocaleFormattedDate(this.rangeEndDate);
},
getLocaleFormattedDate:function(date) {
var dateString, localeCode = this.getCopy("LOCALE");
if (localeCode == "zh_CN" || localeCode == "ja_JP") {
dateString = this.getCopy("WEEKDAYS_MEDIUM."+date.getDay())
+ ", " + date.getFullYear()
+ " " + this.getCopy("YEAR")
+ " " + this.getCopy("MONTHS_SHORT."+date.getMonth())
+ " " + date.getDate()
+ " " + this.getCopy("DAY");
}
else {
dateString = this.getCopy("WEEKDAYS_MEDIUM."+date.getDay())
+ ', ' + date.getDate()
+ ' ' + this.getCopy("MONTHS_SHORT."+date.getMonth())
+ ' ' + date.getFullYear()
}
return dateString;
},
createFramework:function(){
SuperClass.createFramework.call(this);
yuiDom.addClass(this.container,this._CONTAINER_CLASS);
this._rangeStartMessage = this._createToolTip("availableRangeStartMessage","RANGE_START_TOOLTIP");
this._rangeEndMessage = this._createToolTip("availableRangeEndMessage","RANGE_END_TOOLTIP");
},
_createToolTip:function(className,copy){
var div = document.createElement("div");
yuiDom.addClass(div, className);
div.innerHTML = this.getCopy(copy);
document.body.appendChild(div);
return div;
},
createHeader:function(container) {
var closeButton = this.renderCloseButton(container);
// clear calendar
var resetDiv = document.createElement("div");
yuiDom.addClass(resetDiv, "actionLink");
yuiDom.addClass(resetDiv, "resetLink");
var resetAction = document.createElement("a");
yuiEvent.addListener(resetAction, "click", this.handleReset, this, true);
resetAction.title = this.getCopy("RESET");
resetAction.appendChild(document.createTextNode(this.getCopy("RESET")));
resetDiv.appendChild(resetAction);
container.appendChild(resetDiv);
// clear div
Html.appendClearDiv(container);
},
createFooter:function(container){
// create menuHolder Div
this._menuElements = {};
var menuHolder = document.createElement("div");
yuiDom.addClass(menuHolder, "messageContainer");
container.appendChild(menuHolder);
this._menuElements.menuHolder = menuHolder;
// create error display
var errorContainer = document.createElement("ul");
yuiDom.addClass(errorContainer, "errorContainer");
menuHolder.appendChild(errorContainer);
this._menuElements.errorContainer = errorContainer;
var instructions = document.createElement("ol");
yuiDom.addClass(instructions, "instructions");
var checkInInstructions = document.createElement("li");
yuiDom.addClass(checkInInstructions, "rangeStartInstructions");
this._menuElements.rangeStartInstructions = checkInInstructions;
var checkOutInstructions = document.createElement("li");
yuiDom.addClass(checkOutInstructions, "rangeEndInstructions");
this._menuElements.rangeEndInstructions = checkOutInstructions;
var submitInstructions = document.createElement("li");
yuiDom.addClass(submitInstructions, "submitInstructions");
this._menuElements.submitInstructions = submitInstructions;
var continueButtonContainer = document.createElement("div");
yuiDom.addClass(continueButtonContainer, "actionButton");
var continueButton = document.createElement("button");
continueButtonContainer.appendChild(continueButton);
this._menuElements.continueButtonContainer = continueButtonContainer;
this._menuElements.continueButton = continueButton;
yuiEvent.addListener(continueButton, "click", this.submit, this, true);
instructions.appendChild(checkInInstructions);
instructions.appendChild(checkOutInstructions);
instructions.appendChild(submitInstructions);
menuHolder.appendChild(instructions);
},
validateSelectedDate:function(params) {
var selectedDate = params.date;
var selectedRange = null;
if(yuiDom.hasClass(params.cell,"availableRangeStart") && yuiDom.hasClass(params.cell,"availableRangeEnd")){
return false;
}
if(this.rangeStartDate&&!this.rangeEndDate) {
selectedRange = (selectedDate > this.rangeStartDate) ? CalUtils.getLengthOfStay(this.rangeStartDate, selectedDate) : CalUtils.getLengthOfStay(selectedDate, this.rangeStartDate);
}
if(this.rangeEndDate&&!this.rangeStartDate) {
selectedRange = (selectedDate > this.rangeEndDate) ? CalUtils.getLengthOfStay(this.rangeEndDate,selectedDate) : CalUtils.getLengthOfStay(selectedDate,this.rangeEndDate);
}
if(this.rangeStartDate && this.rangeEndDate) {
selectedRange = (selectedDate < this.rangeEndDate) ? CalUtils.getLengthOfStay(selectedDate, this.rangeEndDate) : CalUtils.getLengthOfStay(selectedDate, this.rangeStartDate);
}
if(selectedRange > this.settings.maxRange) {
this.errorArray[this.errorArray.length] = this.getCopy("ERROR_MAX_LOS");
}
return !(this.errorArray.length > 0);
},
validateCalendar:function(){
if(this.rangeStartDate){
if(this.rangeStartDate > this.settings.maxDate){
this.errorArray[this.errorArray.length] = this.getCopy("ERROR_TOO_FAR");
}
if(this.rangeStartDate < this.firstOfStartMonth){
this.errorArray[this.errorArray.length] = this.getCopy("ERROR_START_BEFORE_TODAY");
}
}
if(this.rangeStartDate && this.rangeEndDate){
if(this.rangeEndDate > this.settings.maxDate && this.checkIn < this.settings.maxDate){
this.errorArray[this.errorArray.length] = this.getCopy("ERROR_TOO_FAR");
}
if(CalUtils.getLengthOfStay(this.rangeStartDate, this.rangeEndDate) > this.settings.maxRange){
this.errorArray[this.errorArray.length] = this.getCopy("ERROR_MAX_LOS");
}
if(this.rangeEndDate < this.rangeStartDate){
this.errorArray[this.errorArray.length] = this.getCopy("ERROR_END_BEFORE_START");
}
if(this.rangeStartDate.getTime() == this.rangeEndDate.getTime()){
this.errorArray[this.errorArray.length] = this.getCopy("ERROR_SAME_DATES");
}
}
return !(this.errorArray.length > 0);
},
renderErrors:function(){
if(this.errorArray.length > 0){
var output = [];
for(var i=0; i
' + this.errorArray[i] +'');
}
this._menuElements.errorContainer.innerHTML = output.join("\n");
yuiDom.addClass(this._menuElements.errorContainer, "show");
}else{
yuiDom.removeClass(this._menuElements.errorContainer, "show");
this._menuElements.errorContainer.innerHTML = "";
}
this.errorArray = [];
},
setPosition:function(){
if(this.settings.position && this.settings.trigger){
/*todo convert calls below to yuiDom.getX, getY or getXY*/
if (this.settings.position == "topLeft") {
// display to the top left of the icon
this.container.style.top = (CalUtils.getOffsetTop(this.settings.trigger) - this.container.offsetHeight) + 'px';
this.container.style.left = (CalUtils.getOffsetLeft(this.settings.trigger) - this.container.offsetWidth) + 'px';
} else if (this.settings.position == "topRight") {
// display to the top left of the icon
this.container.style.top = (CalUtils.getOffsetTop(this.settings.trigger) - this.container.offsetHeight) + 'px';
this.container.style.left = CalUtils.getOffsetLeft(this.settings.trigger) + 'px';
} else if (this.settings.position == "bottomRight") {
// display below and to the right of the icon
this.container.style.top = CalUtils.getOffsetTop(this.settings.trigger) + 'px';
this.container.style.left = CalUtils.getOffsetLeft(this.settings.trigger ) + 'px';
} else if (this.settings.position == "bottomLeft") {
// display below and to the right of the icon
this.container.style.top = CalUtils.getOffsetTop(this.settings.trigger) + 'px';
this.container.style.left = (CalUtils.getOffsetLeft(this.settings.trigger) - this.container.offsetWidth) + 'px';
} else if (this.settings.position == "centerLeft") {
// display center and to the left of the icon
this.container.style.top = CalUtils.getOffsetTop(this.settings.trigger) - parseFloat(this.container.offsetHeight)/2 + 'px';
this.container.style.left = (CalUtils.getOffsetLeft(this.settings.trigger) - this.container.offsetWidth) + 'px';
} else if (this.settings.position == "centerRight") {
// display center and to the right of the icon
this.container.style.top = CalUtils.getOffsetTop(this.settings.trigger) - parseFloat(this.container.offsetHeight)/2 + 'px';
this.container.style.left = (CalUtils.getOffsetLeft(this.settings.trigger) ) + 'px';
} else {
// the user tells it where to be placed
// expecting a string with x and y seperated by a comma
var userLocation = this.settings.position.split(",");
this.container.style.top = userLocation[1] + 'px';
this.container.style.left = userLocation[0] + 'px';
}
//this.container.iframe.style.top = this.container.style.top;
//this.container.iframe.style.left = this.container.style.left;
}
return true;
},
// event handlers
handleShow:function(e){
yuiEvent.preventDefault(e);
this.show();
},
handleHide:function(e){
//yuiEvent.preventDefault(e);
this.hide();
}
});
// namespace
YAHOO.namespace("SW.widget.Calendar");
SW.widget.Calendar.StayCalendar = StayCalendar;
})();
(function(){
var yuiEvent = YAHOO.util.Event,
yuiDom = YAHOO.util.Dom,
yuiLang = YAHOO.lang,
yuiConnect = YAHOO.util.Connect,
Html = SW.tools.Html,
Calendar = SW.widget.Calendar.Calendar,
SuperClass = SW.widget.Calendar.StayCalendar.prototype,
CalUtils = SW.widget.Calendar.Utils,
widget = SW.widget;
function AvailabilityCalendar(config){
AvailabilityCalendar.INSTANCES.push(this);
// range dates not valid for Avail
config.rangeStartDate = null;
config.rangeEndDate = null;
SuperClass.constructor.call(this, config);
this.availability = {};
}
AvailabilityCalendar.INSTANCES = [];
// overwrite/extend core CalendarGroup
yuiLang.extend(AvailabilityCalendar, widget.Calendar.StayCalendar,{
_TYPE:"AvailabilityCalendar",
_CONTAINER_CLASS:"availabilityCalendar",
_minLoadTime:0, // exagerated for testing
initialize:function(){
if(!SuperClass.initialize.call(this)) { return false; }
},
initHandlers:function(){
SuperClass.initHandlers.call(this);
// remove basic show/hide - most avail calendars will use animate in/out (this can be altered again in subclass if needed)
/*
this.showEvent.unsubscribe(this.simpleShow);
this.hideEvent.unsubscribe(this.simpleHide);
*/
// standar avail loads data and uses animation in/out
this.showEvent.subscribe(this.showAndLoadData,this,true);
this.hideEvent.subscribe(this.animateOut,this,true);
this.beforeSelectEvent.subscribe(this.validateSelectedDate,this,true);
this.selectEvent.subscribe(this.selectDay,this,true);
this.nextEvent.subscribe(this.handleNext,this,true);
this.previousEvent.subscribe(this.handlePrevious,this,true);
this.beforeRenderEvent.subscribe(this.setRenderers,this,true);
this.beforeShowEvent.subscribe(this.setPosition,this,true);
},
handleNext:function(){
this.getData(this.settings.monthsToDisplay-1);
},
handlePrevious:function(){
this.getData(-(this.settings.monthsToDisplay-1));
},
animateIn:function(){
// as the animations generally need to act on an element which is not part of container, this
// method needs to be defined by instance/subclass
SuperClass.simpleShow.call(this);
},
animateOut:function(){
// as the animations generally need to act on an element which is not part of container, this
// method needs to be defined by instance/subclass
SuperClass.simpleHide.call(this);
},
showAndLoadData:function(){
this.animateIn();
this.getData();
},
getData:function(byMonths){
// we now have toggle methods, which means this method could be called several times before xhr is finished
// todo: if currently loading data - either cancel previous, or handle properly
byMonths = byMonths || 0;
this.showLoading();
var monthToCheck = (byMonths <= 0) ? this.calendars[0].getStartDate() : this.calendars[this.calendars.length-1].getStartDate();
var newRequestDate = new Date(monthToCheck.getFullYear(),((monthToCheck.getMonth())), monthToCheck.getDate());
if(!this.availability[this.getYearMonthCombo(newRequestDate)]){
// get data
this.sendRequest(byMonths);
}
else{
// have data
this.setShowData();
}
},
setShowData:function(){
var self = this,
now = new Date();
var elapsed = now - this._startShowing;
if(elapsed < this._minLoadTime ){
setTimeout(function(){
self.showData();
},(this._minLoadTime - elapsed) * 1000);
}else{
self.showData();
}
},
showData:function(){
this.render();
this.hideLoading();
},
setRenderers:function(){
var date,month,los,monthYear,dateString;
switch(this.getState()){
case Calendar.STATE_UNSELECTED:
// avail check in
for(var i = 0; i < this.calendars.length; i++){
month = this.availability[this.getYearMonthCombo(this.calendars[i].getStartDate())];
if(month){
for(date in month){
if(yuiLang.hasOwnProperty(month,date)){
this.addRenderer(Calendar.RENDER_TYPE_DATE,CalUtils.dateFromString(date),Calendar.renderAvailableRangeStart);
}
}
}
}
break;
case Calendar.STATE_START_SELECTED:
// check in
this.addRenderer(Calendar.RENDER_TYPE_DATE,this.rangeStartDate,Calendar.renderRangeStart);
// avail check
monthYear = this.getYearMonthCombo(this.rangeStartDate);
dateString = CalUtils.dateToSystemFormat(this.rangeStartDate);
date = CalUtils.dateFromString(dateString);
if(this.availability[monthYear]){
for(los in this.availability[monthYear][dateString]){
if(yuiLang.hasOwnProperty(this.availability[monthYear][dateString],los)){
this.addRenderer(Calendar.RENDER_TYPE_DATE,CalUtils.addDays(parseInt(los,10),date,true),Calendar.renderAvailableRangeEnd);
}
}
}
break;
case Calendar.STATE_RANGE_SELECTED:
// check in
this.addRenderer(Calendar.RENDER_TYPE_DATE,this.rangeStartDate,Calendar.renderRangeStart);
// check out
this.addRenderer(Calendar.RENDER_TYPE_DATE,this.rangeEndDate,Calendar.renderRangeEnd);
// selected
this.addRenderer(Calendar.RENDER_TYPE_RANGE,[this.rangeStartDate,this.rangeEndDate],Calendar.renderSelected);
break;
}
},
sendRequest : function(byMonths){
yuiConnect.asyncRequest(
//new service
"GET",
"/corporate/checkAvail.do?" +
"startMonth=" + this.getRequestMonth(this.calendars[0].getStartDate(), byMonths) +
"&endMonth=" + this.getRequestMonth(this.calendars[this.calendars.length -1].getStartDate(), byMonths) +
"&ratePlan=" + this.settings.ratePlan +
"&propertyId=" + this.settings.propertyId +
"&numberOfRooms=" + this.settings.numberRooms +
"&numberOfAdults=" + this.settings.numberAdults,
{success:this.parseResponse, failure:this.parseError, scope:this}
);
},
getRequestMonth:function(date, byMonths){
var newRequestDate = new Date(date.getFullYear(),(date.getMonth()+ byMonths),date.getDate());
return this.getYearMonthCombo(newRequestDate);
},
getYearMonthCombo:function(date){
return date.getFullYear() + "-" + CalUtils.padZero((date.getMonth()+1));
},
parseResponse:function(response){
var dateParts,yearMonth,parsedResponse = yuiLang.JSON.parse(response.responseText);
var dates = parsedResponse.data.availDates;
for(var date in dates){
if(yuiLang.hasOwnProperty(dates,date)){
if(!this.availability[date]){
this.availability[date] = {};
}
this.availability[date] = dates[date];
}
}
this.availability.currencyCode = parsedResponse.data.currencyCode;
this.availability.propertyId = parsedResponse.data.propertyId;
this.availability.ratePlanName = parsedResponse.data.ratePlanName;
this.setShowData();
},
parseError:function(){
this.hideLoading();
this.errorArray[this.errorArray.length] = this.getCopy("ERROR_GENERAL");
this.renderErrors();
},
// consider setting loading class on container and using css to have message appear
showLoading:function(){
this._loading = true;
if(! this._loadingContainer){
this.createLoading(this.container);
}
this._startShowing = new Date();
yuiDom.addClass(this.container, "loading");
},
hideLoading:function(){
this._loading = false;
yuiDom.removeClass(this.container, "loading");
},
isLoading:function(){
return this._loading;
},
createHeader:function(container) {
this.createLegend(container);
// create close button
this.renderCloseButton(container);
/*
var closeButton = document.createElement("div");
yuiDom.addClass(closeButton, "closeLink");
var closeAction = document.createElement("a");
closeAction.href = "#";
yuiEvent.addListener(closeAction, "click", this.handleHide, this, true);
closeAction.title = this.getCopy("CLOSE");
var textNode = document.createTextNode(this.getCopy("CLOSE"));
closeAction.appendChild(textNode);
closeButton.appendChild(closeAction);
container.appendChild(closeButton);
// clear div
Html.appendClearDiv(container);
*/
},
createBody:function(container){
SuperClass.createBody.call(this, container);
// clear div
Html.appendClearDiv(container);
// reset calendar
var resetDiv = document.createElement("div");
yuiDom.addClass(resetDiv,"actionLink");
yuiDom.addClass(resetDiv,"resetLink");
var resetAction = document.createElement("a");
yuiEvent.addListener(resetAction,"click",this.handleReset,this,true);
resetAction.title = this.getCopy("RESET");
var textNode = document.createTextNode(this.getCopy("RESET"));
resetAction.appendChild(textNode);
resetDiv.appendChild(resetAction);
container.appendChild(resetDiv);
// clear div
Html.appendClearDiv(container);
},
createLoading:function(container){
// background is used to prevent mouse interaction with calendars while loading
var loadingBackground = document.createElement("div");
yuiDom.addClass(loadingBackground, "loadingBackground");
container.appendChild(loadingBackground);
var loadingMessage = document.createElement("div");
yuiDom.addClass(loadingMessage, "loadingContainer");
container.appendChild(loadingMessage);
loadingMessage.innerHTML = this.getCopy("LOADING");
this._loadingContainer = loadingMessage;
this._loadingBackground = loadingBackground;
},
createLegend:function(container){
var textNode;
var legend = document.createElement("div");
yuiDom.addClass(legend, "legendContainer");
container.appendChild(legend);
var rangeStartKey = document.createElement("div");
yuiDom.addClass(rangeStartKey, "legendItem");
yuiDom.addClass(rangeStartKey, "rangeStartLegend");
var rangeStartGraphic = document.createElement("div");
yuiDom.addClass(rangeStartGraphic, "rangeStartGraphic");
rangeStartKey.appendChild(rangeStartGraphic);
var rangeStartTextContainer = document.createElement("span");
yuiDom.addClass(rangeStartTextContainer, "legendText");
yuiDom.addClass(rangeStartTextContainer, "rangeStartLegendText");
rangeStartKey.appendChild(rangeStartTextContainer);
textNode = document.createTextNode(this.getCopy("RANGE_START_AVAILABLE"));
rangeStartTextContainer.appendChild(textNode);
var rangeEndKey = document.createElement("div");
yuiDom.addClass(rangeEndKey, "legendItem");
yuiDom.addClass(rangeEndKey, "rangeEndLegend");
var rangeEndGraphic = document.createElement("div");
yuiDom.addClass(rangeEndGraphic, "rangeEndGraphic");
rangeEndKey.appendChild(rangeEndGraphic);
var rangeStartTextContainer = document.createElement("span");
yuiDom.addClass(rangeStartTextContainer, "legendText");
yuiDom.addClass(rangeStartTextContainer, "rangeEndLegendText");
rangeEndKey.appendChild(rangeStartTextContainer);
textNode = document.createTextNode(this.getCopy("RANGE_END_AVAILABLE"));
rangeStartTextContainer.appendChild(textNode);
legend.appendChild(rangeStartKey);
legend.appendChild(rangeEndKey);
// clear div
Html.appendClearDiv(legend);
},
renderFooter:function(){
if(this.rangeStartDate) {
this._menuElements.rangeStartInstructions.innerHTML = this.getCheckInCopy();
yuiDom.addClass(this._menuElements.rangeEndInstructions, "active");
yuiDom.addClass(this._menuElements.rangeStartInstructions, "selected");
} else {
this._menuElements.rangeStartInstructions.innerHTML = this.getCopy("RANGE_START_INSTRUCTIONS");
yuiDom.addClass(this._menuElements.rangeStartInstructions, "active");
yuiDom.removeClass(this._menuElements.rangeStartInstructions, "selected");
}
if(this.rangeEndDate) {
this._menuElements.rangeEndInstructions.innerHTML = this.getCheckOutCopy();
yuiDom.addClass(this._menuElements.rangeEndInstructions, "selected");
} else{
this._menuElements.rangeEndInstructions.innerHTML = this.getCopy("RANGE_END_INSTRUCTIONS");
yuiDom.removeClass(this._menuElements.rangeEndInstructions, "selected");
}
if(this.rangeStartDate && this.rangeEndDate) {
this._menuElements.submitInstructions.innerHTML = this.getSummaryMessage();
this._menuElements.continueButton.innerHTML = this.getCopy("SUBMIT");
yuiDom.addClass(this._menuElements.submitInstructions, "active"); // apply active class to check out div
this._menuElements.submitInstructions.appendChild(this._menuElements.continueButtonContainer);
} else{
yuiDom.removeClass(this._menuElements.submitInstructions, "active"); // apply active class to check out div
if(this._menuElements.continueButtonContainer.parentNode == this._menuElements.submitInstructions) {
this._menuElements.submitInstructions.removeChild(this._menuElements.continueButtonContainer);
}
if(!this.rangeStartDate && !this.rangeEndDate) {
yuiDom.addClass(this._menuElements.rangeStartInstructions, "active"); // apply active class to check out div
yuiDom.removeClass(this._menuElements.rangeEndInstructions, "active");
}
}
},
getSummaryMessage:function() {
var los, monthYear, dateString, summary = "";
//length of stay is reported in days but we display nights in this menu so subtract 1
los = CalUtils.getLengthOfStay(this.rangeStartDate, this.rangeEndDate);
monthYear = this.getYearMonthCombo(this.rangeStartDate);
dateString = CalUtils.dateToSystemFormat(this.rangeStartDate);
summary = "" + los + " " + this.getCopy("NIGHT_STAYS") + "
";
summary += "" + this.getCopy("DAILY_RATE") + ": ";
// can cause issues if comming in with selected dates, but have not run any ajax calls yet
if (this.availability[monthYear]
&& this.availability[monthYear][dateString]
&& this.availability[monthYear][dateString][los]
&& this.availability[monthYear][dateString][los].pts
) {
summary += this.availability[monthYear][dateString][los].pts + " " + this.getCopy("STARPOINTS") + " + ";
}
summary += this.availability.currencyCode + " " + this.availability[monthYear][dateString][los].rate + "
";
return summary;
}
});
// namespace
YAHOO.namespace("SW.widget.Calendar");
SW.widget.Calendar.AvailabilityCalendar = AvailabilityCalendar;
})();