crafatar/modules/helpers.js

var networking = require("./networking");
var logging = require("./logging");
var config = require("./config");
var cache = require("./cache");
var skins = require("./skins");
var renders = require("./renders");
var fs = require("fs");

// 0098cb60-fa8e-427c-b299-793cbd302c9a
var valid_id = /^([0-9a-f-A-F-]{32,36}|[a-zA-Z0-9_]{1,16})$/; // uuid|username
var hash_pattern = /[0-9a-f]+$/;

// gets the hash from the textures.minecraft.net +url+
function get_hash(url) {
  return hash_pattern.exec(url)[0].toLowerCase();
}

function store_skin(id, profile, details, callback) {
  networking.get_skin_url(id, profile, function(url) {
    if (url) {
      var hash = get_hash(url);
      if (details && details.skin === hash) {
        cache.update_timestamp(id, hash);
        callback(null, hash);
      } else {
        logging.log(id + " new skin hash: " + hash);
        var facepath = __dirname + "/../" + config.faces_dir + hash + ".png";
        var helmpath = __dirname + "/../" + config.helms_dir + hash + ".png";
        fs.exists(facepath, function(exists) {
          if (exists) {
            logging.log(id + " skin already exists, not downloading");
            callback(null, hash);
          } else {
            networking.get_from(url, function(img, response, err) {
              if (err || !img) {
                callback(err, null);
              } else {
                skins.extract_face(img, facepath, function(err) {
                  if (err) {
                    logging.error(err);
                    callback(err, null);
                  } else {
                    logging.log(id + " face extracted");
                    skins.extract_helm(id, facepath, img, helmpath, function(err) {
                      logging.log(id + " helm extracted");
                      logging.debug(helmpath);
                      callback(err, hash);
                    });
                  }
                });
              }
            });
          }
        });
      }
    } else {
      callback(null, null);
    }
  });
}

function store_cape(id, profile, details, callback) {
  networking.get_cape_url(id, profile, function(url) {
    if (url) {
      var hash = get_hash(url);
      if (details && details.cape === hash) {
        cache.update_timestamp(id, hash);
        callback(null, hash);
      } else {
        logging.log(id + " new cape hash: " + hash);
        var capepath = __dirname + "/../" + config.capes_dir + hash + ".png";
        fs.exists(capepath, function(exists) {
          if (exists) {
            logging.log(id + " cape already exists, not downloading");
            callback(null, hash);
          } else {
            networking.get_from(url, function(img, response, err) {
              if (err || !img) {
                logging.error(err);
                callback(err, null);
              } else {
                skins.save_image(img, capepath, function(err) {
                  logging.log(id + " cape saved");
                  callback(err, hash);
                });
              }
            });
          }
        });
      }
    } else {
      callback(null, null);
    }
  });
}

// downloads the images for +id+ while checking the cache
// status based on +details+. +type+ specifies which
// image type should be called back on
// +callback+ contains the error buffer and image hash
var currently_running = [];
function callback_for(id, type, err, hash) {
  for (var i = 0; i < currently_running.length; i++) {
    var current = currently_running[i];
    if (current.id === id && current.type === type) {
      logging.debug(id + " now completing queued " + type + " request");
      current.callback(err, hash);
      currently_running.splice(i, 1); // remove from array
      i--;
    }
  }
}

function array_has_obj(arr, property, value) {
  for (var i = 0; i < arr.length; i++) {
    if (arr[i][property] === value) {
      return true;
    }
  }
  return false;
}

function store_images(id, details, type, callback) {
  var is_uuid = id.length > 16;
  var new_hash = {
    id: id,
    type: type,
    callback: callback
  };
  if (!array_has_obj(currently_running, "id", id)) {
    currently_running.push(new_hash);
    networking.get_profile((is_uuid ? id : null), function(err, profile) {
      if (err || (is_uuid && !profile)) {
        callback_for(id, type, err, null);
      } else {
        store_skin(id, profile, details, function(err, skin_hash) {
          cache.save_hash(id, skin_hash, null);
          callback_for(id, "skin", err, skin_hash);
          store_cape(id, profile, details, function(err, cape_hash) {
            cache.save_hash(id, skin_hash, cape_hash);
            callback_for(id, "cape", err, cape_hash);
          });
        });
      }
    });
  } else {
    logging.log(id + " ID already being processed, adding to queue");
    currently_running.push(new_hash);
  }
}

var exp = {};

// returns true if the +id+ is a valid uuid or username
// the id may be not exist, however
exp.id_valid = function(id) {
  return valid_id.test(id);
};

// decides whether to get an image from disk or to download it
// callback contains error, status, hash
// the status gives information about how the image was received
//  -1: "error"
//   0: "none" - cached as null
//   1: "cached" - found on disk
//   2: "downloaded" - profile downloaded, skin downloaded from mojang servers
//   3: "checked" - profile re-downloaded (was too old), but it has either not changed or has no skin
exp.get_image_hash = function(id, raw_type, callback) {
  cache.get_details(id, function(err, details) {
    var type = (details !== null ? (raw_type === "skin" ? details.skin : details.cape) : null);
    if (err) {
      callback(err, -1, null);
    } else {
      if (details && details.time + config.local_cache_time * 1000 >= new Date().getTime()) {
        logging.log(id + " id cached & recently updated");
        callback(null, (type ? 1 : 0), type);
      } else {
        if (details) {
          logging.log(id + " id cached, but too old");
        } else {
          logging.log(id + " id not cached");
        }
        store_images(id, details, raw_type, function(err, hash) {
          if (err) {
            callback(err, -1, details && type);
          } else {
            var status = details && (type === hash) ? 3 : 2;
            logging.debug(id + " old hash: " + (details && type));
            logging.log(id + " hash: " + hash);
            callback(null, status, hash);
          }
        });
      }
    }
  });
};


// handles requests for +id+ avatars with +size+
// callback contains error, status, image buffer, hash
// image is the user's face+helm when helm is true, or the face otherwise
// for status, see get_image_hash
exp.get_avatar = function(id, helm, size, callback) {
  logging.log("request: " + id);
  exp.get_image_hash(id, "skin", function(err, status, hash) {
    if (hash) {
      var facepath = __dirname + "/../" + config.faces_dir + hash + ".png";
      var helmpath = __dirname + "/../" + config.helms_dir + hash + ".png";
      var filepath = facepath;
      fs.exists(helmpath, function(exists) {
        if (helm && exists) {
          filepath = helmpath;
        }
        skins.resize_img(filepath, size, function(img_err, result) {
          if (img_err) {
            callback(img_err, -1, null, hash);
          } else {
            // we might have a hash although an error occured
            // (e.g. Mojang servers not reachable, using outdated hash)
            callback(err, (err ? -1 : status), result, hash);
          }
        });
      });
    } else {
      // hash is null when the id has no skin
      callback(err, status, null, null);
    }
  });
};

// handles requests for +id+ skins
// callback contains error, hash, image buffer
exp.get_skin = function(id, callback) {
  logging.log(id + " skin request");
  exp.get_image_hash(id, "skin", function(err, status, hash) {
    var skinpath = __dirname + "/../" + config.skins_dir + hash + ".png";
    fs.exists(skinpath, function (exists) {
      if (exists) {
        logging.log(id + " skin already exists, not downloading");
        skins.open_skin(id, skinpath, function(err, img) {
          callback(err, hash, img);
        });
      } else {
        networking.save_texture(id, hash, skinpath, function(err, img) {
          callback(err, hash, img);
        });
      }
    });
  });
};

function get_type(helm, body) {
  var text = body ? "body" : "head";
  return helm ? text + "helm" : text;
}

// handles creations of skin renders
// callback contanis error, hash, image buffer
exp.get_render = function(id, scale, helm, body, callback) {
  exp.get_skin(id, function(err, hash, img) {
    if (!hash) {
      callback(err, -1, hash, null);
      return;
    }
    var renderpath = __dirname + "/../" + config.renders_dir + hash + "-" + scale + "-" + get_type(helm, body) + ".png";
    fs.exists(renderpath, function(exists) {
      if (exists) {
        renders.open_render(id, renderpath, function(err, img) {
          callback(err, 1, hash, img);
        });
        return;
      } else {
        if (!img) {
          callback(err, 0, hash, null);
          return;
        }
        renders.draw_model(id, img, scale, helm, body, function(err, img) {
          if (err) {
            callback(err, -1, hash, null);
          } else if (!img) {
            callback(null, 0, hash, null);
          } else {
            fs.writeFile(renderpath, img, "binary", function(err) {
              if (err) {
                logging.log(err);
              }
              callback(null, 2, hash, img);
            });
          }
        });
      }
    });
  });
};


// handles requests for skin of the +id+
// callback contains error, hash, image buffer
exp.get_skin = function(id, callback) {
  logging.log(id + " skin request");
  exp.get_image_hash(id, "skin", function(err, status, hash) {
    var skinpath = __dirname + "/../" + config.skins_dir + hash + ".png";
    fs.exists(skinpath, function(exists) {
      if (exists) {
        logging.log("skin already exists, not downloading");
        skins.open_skin(id, skinpath, function(err, img) {
          callback(err, hash, img);
        });
      } else {
        networking.save_texture(id, hash, skinpath, function(err, response, img) {
          callback(err, hash, img);
        });
      }
    });
  });
};

// handles requests for +id+ capes
// callback contains error, hash, image buffer
exp.get_cape = function(id, callback) {
  logging.log(id + " cape request");
  exp.get_image_hash(id, "cape", function(err, status, hash) {
    if (!hash) {
      callback(err, null, null);
      return;
    }
    var capepath = __dirname + "/../" + config.capes_path + hash + ".png";
    fs.exists(capepath, function(exists) {
      if (exists) {
        logging.log("cape already exists, not downloading");
        skins.open_skin(id, capepath, function(err, img) {
          callback(err, hash, img);
        });
      } else {
        networking.save_texture(id, hash, capepath, function(err, response, img) {
          if (response && response.statusCode === 404) {
            callback(err, hash, null);
          } else {
            callback(err, hash, img);
          }
        });
      }
    });
  });
};

module.exports = exp;