Mundial RUSIA 2018

Rusia [MOSCOW]

Información del Evento
Fecha: 14 junio, 2018
Time: 12:00
Ubicación: Rusia
Dirección: MOSCOW
Web: https://es.fifa.com/worldcup/
Evento: #
Detalles







Minuto a minuto


});
});

//Una vez inicializado el carrusel, eliminamos los partidos en diferido que haya que eliminar
handleDeferred();
//Mover al índice inicial
owl.goTo(findStartIndex());

addDataSrc(owl.visibleItems);

var currentPage = 0,
matchList = $(“.item_partido”),
matchCount = matchList.size(),
partidosVivo = new Object();

function loadData(matchArray,mIndex){

if ( (mIndex < matchArray.length) && appConfigLoaded) {
var thisMatch = matchArray[mIndex],
id = thisMatch.attr(“data-matchid”),
tournament = thisMatch.attr(“data-title”),
sportChannel = thisMatch.attr(“data-sportChannel”),
matchId = thisMatch.attr(“data-matchid”);

var channel = “deportes.” + sportChannel + “.” + tournament + “.” + matchId;
var eventParams = $.extend(true, {}, appConfig.defaultParams.eventsParams(channel), appConfig.customParams.eventsParams(channel));

//Arma la URL de consulta
//var url = “http://feed.datafactory.la/index.php?ppaass=updl88updn&test=update&canal=”+canal;

var eventDataUrl = dataBasePath + sportChannel + “/” + tournament + “/events/” + id + “.mam.json?_=” + new Date().getTime();

if(eventParams.dataSourcePath !== undefined){
eventDataUrl = eventParams.dataSourcePath
.replace(“%%tournamentPath%%”, eventParams.tournamentPath)
.replace(“%%EVENT_TYPE%%”, “deportes”)
.replace(“%%EVENT_CATEGORY%%”, sportChannel)
.replace(“%%TOURNAMENT%%”, tournament)
.replace(“%%EVENT_NO%%”, matchId + “.mam”);
eventDataUrl = (eventDataUrl.search(/(http:|https:)?\/\//i) === -1) ? (htmlCenterBasePath + eventDataUrl) : eventDataUrl;
}

//Realiza la consulta a datafactory
if (id) {
$.ajax({
type: “GET”,
url: eventDataUrl,
dataType: “json”,
cache: false,
success: function(data) {
var vivo = “”;
var estado = data.status.value;
var IDestado = data.status.statusId
var idDeporte = thisMatch.attr(“data-sportid”);
var statusClass;
var itemMaM = thisMatch.find(“.itemMaM”);
var sportsWithMarquee = [1,2,37];

if(estado != ”){
//estado = $(data).find(“fichapartido”).attr(“nombreDia”)+” “+$(data).find(“fichapartido”).attr(“dia”).substring(6,8)+” – “+$(data).find(“fichapartido”).attr(“horario”)+” hs.”;
thisMatch.find(“.mc-status”).text(lang.sports[“s”+idDeporte].status[estado.replace(/[^a-zA-Z 0-9]/g, “”)]);
}
if(estado == ‘Finalizado’){
thisMatch.addClass(“fin”).addClass(“ready”);
}

//Estado del evento
switch (idDeporte) {
case “4”:
switch (IDestado) {
case 1:
case 2:
case 3:
case 4:
case 5:
statusClass = “status-playing”;
break;
case 8:
statusClass = “status-finished”;
break;
case 7:
statusClass = “status-suspended”;
break;
case 9:
statusClass = “status-postponed”;
break;
case 6:
statusClass = “status-half”;
break;
default:
statusClass = “status-notStarted”;
break;
}
break;
case “5”:
switch (IDestado) {
case 1:
case 2:
case 3:
case 4:
case 5:
case 9:
statusClass = “status-playing”;
break;
case 7:
case 8:
statusClass = “status-finished”;
break;
case 6:
statusClass = “status-suspended”;
break;
default:
statusClass = “status-notStarted”;
break;
}
break;
case “37”:
switch (IDestado) {
case 1:
case 2:
case 3:
case 4:
statusClass = “status-playing”;
break;
case 5:
statusClass = “status-penalties”;
break;
case 6:
statusClass = “status-finished”;
break;
case 7:
statusClass = “status-suspended”;
break;
case 8:
statusClass = “status-postponed”;
break;
case 9:
case 10:
case 11:
case 12:
statusClass = “status-half”;
break;
default:
statusClass = “status-notStarted”;
break;
}
break;
default:
switch (IDestado) {
case 1:
case 6:
case 8:
case 10:
case 14:
statusClass = “status-playing”;
break;
case 2:
statusClass = “status-finished”;
break;
case 3:
statusClass = “status-suspended”;
break;
case 4:
statusClass = “status-postponed”;
break;
case 5:
case 7:
case 9:
case 11:
case 15:
statusClass = “status-half”;
break;
case 12:
statusClass = “status-penalties”;
break;
case 13:
statusClass = “status-kicks”;
break;
default:
statusClass = “status-notStarted”;
break;
}
break;
}

if(!itemMaM.hasClass(statusClass)){
itemMaM.removeClass(“status-playing status-finished status-suspended status-postponed status-half status-penalties status-kicks status-notStarted”);
itemMaM.addClass(statusClass);
}

thisMatch.find(“.mc-team”).each(function(){
var idEquipo = “”+$(this).data(“id”);

var goles = (data.scoreStatus[idEquipo].score != null) ? data.scoreStatus[idEquipo].score : “-“,
golesPenal = data.scoreStatus[idEquipo].scorePenaltyRow;

$(this).find(“.js-score”).html(goles);
if(idDeporte == 4 || idDeporte == 5){
var i = 0,
target = thisMatch.find(‘.middle ul.t’+idEquipo),
periods = data.scoreStatus[idEquipo].periods;

for(var k in periods) {
if(periods[k].r !== ”){
if($(target).find(‘li’).eq(i).size() == 0){
$(target).append(‘<li><span>’+periods[k].r+'</span></li>’);
}else{
$(target).find(“li:eq(“+i+”) span”).html(periods[k].r);
}
//Si tiene un subresultado, se lo agrego
if(periods[k].hasOwnProperty(‘sr’)){
$(target).find(“li:eq(“+i+”) span”).append(‘<sup>(‘+periods[k].sr+’)</sup>’);
}
}
i++;
}
}
if(golesPenal != null){
$(this).find(“.js-penalty-score”).show().html(golesPenal);
}

});
//Mostrar el saque en el caso de que el partido se encuentre en juego
//(funciona para tenis solamente)
if(idDeporte == 5){
//Ocultar por default los saques
thisMatch.find(“.mc-team .mc-service”).hide();

//Verificar si el partido está en vivo y mostrar el saque donde corresponda
if(statusClass === “status-playing”){
for(var teamId in data.scoreStatus){
if(data.scoreStatus[teamId].service){
thisMatch.find(“.mc-teams [data-id=” + teamId + “] .mc-service”).show();
}
}
}
}

// fijarse si no es mam tipo2 en lugar del deporte
if(sportsWithMarquee.indexOf(parseInt(idDeporte)) !== -1){
var marqueText = “”;
var getMarqueeTexts = function(obj){
for (var prop in obj) {
var inc = obj[prop];
var elapsedTime = 0;
half = parseInt(inc.t.half);

for(var i=0; i<=(half-2);i++){
elapsedTime += lang.sports[“s”+idDeporte].periodDurations[i];
}
time = inc.t.m – elapsedTime;
var idInc = (typeof lang.sports[“s”+idDeporte].marquesina[“type_”+inc.type] == “number”) ? lang.sports[“s”+idDeporte].marquesina[“type_”+inc.type] : inc.type;

var nameInfo = data.players[inc.plyrId].name;
var playerName;

if( (typeof nameInfo.shortName !== “undefined”) && (nameInfo.shortName !== null) ){
playerName = nameInfo.shortName;
}
else if( (typeof nameInfo.nick !== “undefined”) && (nameInfo.nick !== null) ){
playerName = nameInfo.nick;
}
else{
playerName = (nameInfo.first + ‘ ‘ + nameInfo.last);
}
var teamName = data.teams[inc.team].name;

marqueText += lang.sports[“s”+idDeporte].marquesina[“type_”+idInc]+teamName+”: “+lang.sports[“s”+idDeporte].tiempos[“h”+inc.t.half]+” “+time+”‘ – “+playerName+” // “;
}
}
getMarqueeTexts(data.incidences.goals);
getMarqueeTexts(data.incidences.points);

if(marqueText != thisMatch.find(“.marqueeItem”).html()){
thisMatch.find(“.marqueeItem”).html(marqueText);
thisMatch.find(‘.mc-marquee’).marquee(‘destroy’);
thisMatch.find(‘.mc-marquee’).marquee();
}
if(statusClass == ‘status-playing’){ vivo = true}
//Reloj del partido
if(vivo == true){
if(partidosVivo[“p”+id] == undefined){
var horaEstadoEvento = data.status.startHour+”:”+data.status.startMinute+”:”+data.status.startSecond;
var dia = data.match.date;
partidosVivo[“p”+id] = window.setInterval(function(){
thisMatch.find(“.mc-time”).html(getElapsedTime(dia.substring(0,4),parseInt(dia.substring(4,6)) – 1,dia.substring(6,8),horaEstadoEvento.substring(0,2),horaEstadoEvento.substring(3,5),horaEstadoEvento.substring(6,8)));
},1000);
}
}else{
if(partidosVivo[“p”+id] != undefined){
window.clearInterval(partidosVivo[“p”+id]);
partidosVivo[“p”+id] = undefined;
thisMatch.find(“.mc-time”).html(“”);
}
}
}

loadData(matchArray,mIndex + 2);
},
error: function (msg) {
loadData(matchArray,mIndex + 2);
//console.log(textStatus);
}
});
}
}
}

function dataRefresh(){
var matchArray = [];
matchList = $(“.item_partido”);
for(var i = 0; i < owl.visibleItems.length; i++){
var thisMatch = matchList.eq(owl.visibleItems[i]);
if(!thisMatch.hasClass(“ready”)){
//Si el partido lo cargue, y esta finalizado, no lo actualizo
matchArray.push(thisMatch);
}
}
loadData(matchArray,0);
loadData(matchArray,1);
}

dataRefresh();
convierteFecha();

/*
FALTA

levantar la URL del SSA del mc.config

*/

var ssaAttempsCounter = 0,
ssaRetryAttemps = 20,
ssaRetryTimer = 2;

function getEventPurchasedCoverage(channelCoverage,eventCoverage,homeTeam,awayTeam){

//Inicializo la cobertura comprada a la contratada del canal
var purchasedCoverage = channelCoverage.default;

//Verificar si hay excepciones que sobreescriban a la cobertura contratada
if(typeof channelCoverage.exceptions !== “undefined”){

var exceptions = channelCoverage.exceptions;

//Busco si hay una excepción del tipo team1&team2, la cual aplica al encuentro entre dos equipos
if( typeof exceptions[homeTeam + “&” + awayTeam] !== “undefined” ){
purchasedCoverage = exceptions[homeTeam + “&” + awayTeam];
}
else if( typeof exceptions[awayTeam + “&” + homeTeam] !== “undefined” ){
purchasedCoverage = exceptions[awayTeam + “&” + homeTeam];
}
//Busco si hay excepciones para los dos equipos por separado
else if( (typeof exceptions[homeTeam] !== “undefined”) && (typeof exceptions[awayTeam] !== “undefined”) ){
//En este caso sobreescribo con la mayor
purchasedCoverage = (exceptions[homeTeam] >= exceptions[awayTeam]) ? exceptions[homeTeam] : exceptions[awayTeam];
}
//Busco si hay excepciones para el equipo local
else if(typeof exceptions[homeTeam] !== “undefined”){
purchasedCoverage = exceptions[homeTeam];
}
//Busco si hay excepciones para el equipo visitante
else if(typeof exceptions[awayTeam] !== “undefined”){
purchasedCoverage = exceptions[awayTeam];
}

}

//Comparara la cobertura comprada con la cobertura máxima del evento y devolver la menor
var finalCoverage = ( parseInt(purchasedCoverage) <= parseInt(eventCoverage) ) ? purchasedCoverage : eventCoverage;

return finalCoverage;

}

function ssaCheck(ssaUrl){
if(ssaUrl == ”){ ssaUrl = ‘//ssa.datafactory.la/htmlCenterCheck.php?api=%%API_KEY%%’}
ssaUrl = ssaUrl.replace(/%%API_KEY%%/g, ‘dfMc-742105e492b2922’);
//console.debug(“consulto al SSA….”);

var authAjaxCall = $.ajax({
type: ‘GET’,
url: ssaUrl,
timeout: 4000,
cache: false,
dataType: ‘jsonp’,
async: true,
crossDomain: true,
contentType: ‘application/json; charset=UTF-8′,
});

authAjaxCall.done(function (response) {
if (typeof response.error !== “undefined”) {

} else {

$(“.item_partido”).each(function(){
var este = $(this),
deporte = este.data(“sportchannel”),
eventId = “deportes.”+deporte+”.”+este.data(“title”);
// Seteo la cobertura
var coverageLevelPerChannel = response.coverageLevel;
var cob = false;
for (var channel in coverageLevelPerChannel) {

if (coverageLevelPerChannel.hasOwnProperty(channel)) {
if (eventId.match(channel)) {
cob = coverageLevelPerChannel[channel];
break;
}
}
}

var homeId = este.find(“.mc-homeTeam”).data(“id”);
var awayId = este.find(“.mc-awayTeam”).data(“id”);

var eventCoverage = parseInt(este.data(“coverage”));
var currentCoverage = getEventPurchasedCoverage(cob,eventCoverage,homeId,awayId);

/*console.debug(“event”, este.data(“matchid”));
console.debug(“cob”, cob);
console.debug(“eventCoverage”, eventCoverage);
console.debug(“currentCoverage”, currentCoverage);
console.debug(“———-“);*/

//Configuración de botón de detalles
var showDetailsConfig = {
“futbol” : {
“minCoverage” : 600
},
“futbolplaya” : {
“minCoverage” : 600
},
“rugby” : {
“minCoverage” : 700
}
};

//Coberturas en diferido
var deferredCoveragesConfig = {
“basquet” : [300],
“futbol” : [400],
“futbolplaya” : [400],
“rugby” : [400],
“tenis” : [300]
};

//Habilitar el botón de detalles si se cumple con la cobertura
var detailsCoverage = (typeof showDetailsConfig[deporte] !== “undefined”) ? showDetailsConfig[deporte].minCoverage : null;

if( (detailsCoverage !== null) && (currentCoverage >= detailsCoverage) ){
este.find(“.hideDetailsButton”).removeClass(“hideDetailsButton”);
}

//Añadir la clase de diferido si la cobertura es la correspondiente
var deferredCoverages = (typeof deferredCoveragesConfig[deporte] !== “undefined”) ? deferredCoveragesConfig[deporte] : null;

if( (deferredCoverages !== null) && (deferredCoverages.indexOf(currentCoverage) !== -1) ){
//console.debug(“deferred”);
este.addClass(“deferred”);
este.find(“.mc-deferredLabel”).show();
}

//console.debug(eventId+”: “+cob.default);
});

handleDeferred();//LLamada al manejador de diferidos

}

return;
});

authAjaxCall.fail(function (jqxhr, textStatus, error) {

// Intento nuevamente
ssaAttempsCounter++;

//console.debug(“Falló la consulta al SSA, reintento en “+Math.round(ssaRetryTimer)+” segundos. Intento “+ssaAttempsCounter+” de “+ssaRetryAttemps);

if (ssaAttempsCounter <= ssaRetryAttemps) {

setTimeout(ssaCheck, Math.round(ssaRetryTimer * 1000), ssaUrl);
ssaRetryTimer = ssaRetryTimer * 1.25;

return;
} else {
//console.debug(“Se agotaron los intentos. No se ha podido conectar con el servidor de DataFactory.”);

}

});
}

var segundero = setInterval(function(){
dataRefresh(); //Nueva llamada
handleDeferred();//LLamada al manejador de diferidos
},10000);

//Calcula el reloj del partido
function getElapsedTime(anio,mes,dia,hora,minuto,segundo){

var gmt1 = ( originalGMT * 60 * 60 * 1000);
//hora en la que esta programada el inicio del partido
var date1 = new Date(anio,mes,dia,hora,minuto,segundo);
var d1 = date1.getTime();

var date2 = new Date();
var gmt2 = -date2.getTimezoneOffset() * 60 * 1000;
var d2 = date2.getTime();
var prueba = (d2 – d1)/1000/60/60;
if((d2 – d1)/1000/60/60 > 12){
//Si la difeencia de horas entre el inicio del evento y el inicio del partido es mayor a 12 horas, entonces asumo que el evento inicio en el dia siguiente
//Esto aplica cuando un partido inicia un dia, y el segundo tiempo o el alargue inicia en el proximo
d1 += 24 * 60 * 60 * 1000;
}
var dif = (d2-(d1+(gmt2 – gmt1)));
var h = parseInt(dif/1000/60/60);
var m = parseInt((dif/1000/60)-(h*60));
var s = parseInt((dif/1000)-(h*60*60)-(m*60));
return (h>0)?’–:–‘:((m>9?m:’0’+m) +’:’+ (s>9?s:’0’+s));

}

</script>

</body></html>

Current track
TITLE
ARTIST

Background