Namespace.register("U.Dk.UP"); //Disk上传的命名空间

//#region 上传区域 Html5 Flash html

U.Dk.UP.FTF = {
    "FL": [] //所有上传的文件数组 
};

/**
* 生成上传的点击框
* @param  {string}  需要加载上传框的元素
* @param  {object}  加载上传框的flash的信息
* @param  {string}  用户的id
* @param  {boolean}  是否允许直接加载flash框 ，如果是true则不需要权限直接加载
*/
U.Dk.UP.SCXWPOP = function (el, flashinfo, userid, ifload) {
    var _iscreate, //查看flash是否创建成功
    _uploadinfo = U.Dk.UP.FTF, //flash上传使用的全局变量
    _diskinfo = U.Dk.DiskOperatingSwitch(userid || US.userInfo.userid), //获取用户网盘的信息
    _permis = U.Dk.HP.WPCZQXHQ(_diskinfo[1][1]); //获取上传的权限 包含ftp中有只允许上传的情况 只允许下载的情况 或者是在他人云盘中不允许上传等等具体看函数内部的注释

    //如果用户需要上传判断用户是否需要通登录后才能使用，如果第四个传参是允许加载那么就直接加载
    if (!U.U.L.isLogin(3) || _permis[0] || ifload == true) {
        //允许上传
        //添加属性设置
        flashinfo["width"] = flashinfo["width"] || $(el).width();
        flashinfo["height"] = flashinfo["height"] || $(el).height();

        //全局变量记录需要创建的flash
        _uploadinfo["FUN"] = flashinfo;

        //添加flash按钮
        U.UP.AddFAN(el, flashinfo["ID"] + userid, flashinfo);

        //设置上传按钮的回调事件
        _UTF = U.UP.FAFZ(_$(flashinfo).GZDL["width", "height"],
             {
                 EX: U.Dk.UP.XWPOPC, //错误处理回调函数
                 ADD: U.Dk.UP.XSSCXWPOP, //选择文件回调函数
                 FUP: U.Dk.UP.XWPOPL, //获取文件的上传流
                 JDT: U.Dk.UP.XWPJDT, //上传文件的进度条处理
                 CP: U.Dk.UP.XWPCB, //单个文件上传成功的回调函数
                 FCP: U.Dk.UP.XWPCBC, //单个文件上传成功后，得到服务器的响应值处理，和CP不一样的是这里是得到了返回值，上面的只是文件已经传输到服务器了。
                 ACP: U.Dk.UP.XWPGBSC//全部文件都上传成功后执行
             }
             , flashinfo["GS"]); //设置上传响应回调
        return true;

    }
    //查看flash是否创建成功 创建失败移除元素
    if (_iscreate == null) {
        ($("object", el) || $("embed", el)).remove();
    }
    return false;
}


/**
* 判断用户是否具有权限生成上传的点击框
* @param  {string}  需要上传用户的id
*/
U.Dk.UP.XWPOP = function (userid) {
    var _diskinfo = U.Dk.DiskOperatingSwitch(userid); //获取用户网盘信息
    //如果用户网盘加载成功点击上传才有效
    if (_diskinfo) {
        var _permit = U.Dk.HP.WPCZQXHQ(_diskinfo[1][1]); //获取该目录的上传权限
        if (_permit[0]) { //允许上传
            var _flashforms = U.Dk.UP.SCSCK(); //创建、弹出上传框
            U.D.PopupWindow(_flashforms); //设置上传框弹出
        }
    }
}

/**
* 生成上传的点击框
* @param  {array}  需要加载上传框的元素
*/
U.Dk.UP.XSSCXWPOP = function (uploadfiles) {
    var _flashinfo = U.Dk.UP.FTF, //上传的全局变量
    _diskinfo = US.Disk.UserDisk, //用户网盘信息
    _uploadinfo = _flashinfo["FUN"], //flash上传信息
    _flashel = U.UP.FTF["EL"]; //flash元素

    //判断上传信息中是否通过打开网盘的信息上传
    if (_uploadinfo["DS"]) {
        U.Dk.UP.SCSCK(); //弹出上传框
    }
    U.Dk.UP.UAXWP(uploadfiles); //显示需要上传的内容
}

/**
* 弹出用户网盘信息
*/
U.Dk.UP.SCSCK = function () {
    var _UDOD, _UDTD, _panel, _UDCD;

    if ($("#UD_SYVO")[0]) {
        return $("#UD_SYVO").Center()[0];
    }
    else {
        if (!(_UDOD = $("#UD_SYV")[0])) {
            _UDOD = $$("div", { "id": "UD_SYV", "className": "UD_SYV", "onmousedown": [[U.D.DragMouseDown, ["this"]]] });
            _UDTD = $$("div", { "className": "UD_SYVO" }, _UDOD);
            _panel = $$("div", { "className": "UD_SYVT" }, _UDTD);
            $$("div", { "className": "UD_SYVTO", "innerHTML": "普通上传" }, _panel);
            $$("div", { "className": "UD_SYVZ", "onmousedown": U.M.StopBubble, "innerHTML": " 提示声明: 严谨上传包括反动、暴力、色情、违法及侵权内容的文件；严格遵守保密法律法规，任何危害用户或犯法的行为，都必须受到法律追究。" }, _UDTD);
            $$("div", { "className": "UD_SYVC", "id": "UD_SYVC", "onmousedown": U.M.StopBubble }, _UDTD);
            _panel = $$("div", { "className": "UD_SYVD", "onmousedown": U.M.StopBubble }, _UDTD);
            _UDCD = $$("div", { "className": "UD_SYVDR" }, _panel); $$("div", { "className": "UD_SYVDRO", "innerHTML": "添加文件" }, _UDCD); $$("div", { "className": "UD_SYVDRO UD_SYVDRT", "id": "UD_SYVDRT" }, _UDCD);
            $$("div", { "className": "UD_SYMI UD_SYI UD_SYVB", "title": "关闭", "onmousedown": U.M.StopBubble, "onclick": [[U.D.CloseWindow, [_UDOD]]] }, _UDOD);
            $("body").append(_UDOD);
        }
        _UDOD.style.display = "block";
        return U.UI.Form({ id: "UD_SYVO", style: { width: "720px", height: "520px;" }, content: _UDOD, title: "<div class='UD_SYF_STI'>文件上传</div>", hst: { style: { "padding": "0"}} }).be;
    }
}

/**
* 上传文件权限处理和过滤
* @param  {array}  上传的文件数组
*/
U.Dk.UP.UAXWP = function (uploadfiles) {
    try {
        var i, j, _panel,
        _fileslength, //需要上传的文件夹的文件长度
        _uploadlength, //根据条件得到的文件夹大小
        _diskinfo = US.Disk.UserDisk, //当前网盘
        _length = uploadfiles.length, //用户选择上传的数量
        _flashinfo = U.Dk.UP.FTF, //flash的全局变量
        _allfiles = _flashinfo["FL"], //获取所有需要上传的文件
        _uploaddiv = _diskinfo ? _diskinfo[1][1] : US.FG, //获取上传到那个目录的id
        _uploadcontent = $("#UD_SYVC"); //上传区域

        //如果上传文件是上传到指定目录中的处理
        if (_diskinfo && _diskinfo[4][_uploaddiv]) {
            _fileslength = _$(_diskinfo[4][_uploaddiv].Child).Select({ "filetype": 1 }).length; //获取当前要上传的目录的文件长度
            _uploadlength = (1000 - _fileslength) > _length ? _length : 1000 - _fileslength; //该目录能上传的大小

            uploadfiles.slice(0, _uploadlength); //截取能上传后的文件
            j = _length - _uploadlength; //根据上面的条件如果移除了上传的控件则通知flash同步删除 ，获取需要移除的文件数

            for (i = 0; i < j; i++) { //循环移除
                U.UP.FTF["EL"].DF(_length - i - 1, _allfiles.length - 1); //移除
            }
        }
        //判断是否还有文件可以上传
        if (uploadfiles.length) {
            _allfiles.push(uploadfiles); //添加一个上传等待

            //给每个需要上传的变量添加下面的值
            U.Ut.AddArr(uploadfiles, {
                "UGE": _diskinfo, //上传到那个网盘
                "UFN": _flashinfo["FUN"], //上传成功的回调
                "userid": _diskinfo ? _diskinfo[1][2] : US.userInfo.userid, //上传到那个用户
                "ID": _uploaddiv, //上传到那个目录的id
                "URL": _flashinfo["FUN"]["URL"], //上传的地址
                "SO": U.UP.FTF["EL"] //上传对应的flash按钮
            });
            U.Dk.UP.PrintUploadFiles(uploadfiles); //打印需要上传的信息

            U.Dk.UP.XWPOPX(0, 0, uploadfiles[0]);  //这里主要的作用是连续点击上传，多次上传排序上传
        }
        else {//文件数量限制处理
            U.Alert(_length == uploadfiles.length ? "上传文件格式不符合要求！" : "文件超过最大范围");
            U.UP.FTF["EL"].Delqy(_UPE.length);
        }
    }
    catch (e) { }

}

/**
* 打印上传的信息
* @param  {array}  上传的文件数组
*/
U.Dk.UP.PrintUploadFiles = function (uploadfiles) {
    var _type,
    _info,
    _uploaddiv,
    _panel,
    _panel_one,
   _frag = $$("frag");
    for (i = 0; i < uploadfiles.length; i++) {
        _type = uploadfiles[i]["type"]; //获取上传文件的后缀
        _info = U.Dk.HP.GetIcon(_type); // U.UP.XWPGYS(_type); //获取上传文件格式的的样式
        uploadfiles[i].FID = Guid.newGuid(); //上传文件唯一识别id

        uploadfiles[i]["UDOD"] = _uploaddiv = $$("div", { "className": "UD_SYVCO" }, _frag);
        _panel = $$("div", { "className": "UD_SYVCOO" }, _uploaddiv);
        _uploaddiv = $$("div", { "className": "UD_SYVCOI UD_SYID " + _info.classname[0] }, _panel);
        if (_info.name == "文档") {
            $$("div", { "className": "UD_SYVCOION", "innerHTML": _type }, _uploaddiv)
        }
        _uploaddiv = $$("div", { "className": "UD_SYVCOT" }, _panel);
        $$("div", { "className": "UD_SYVCOTS UTDF", "innerHTML": uploadfiles[i].name }, _uploaddiv);
        $$("div", { "className": "UD_SYVCOTC", "innerHTML": "分类:" + _info.name }, _uploaddiv);
        $$("div", { "className": "UD_SYVCOTX", "innerHTML": "容量大小:" + U.UP.FileSize(uploadfiles[i]["size"]) }, _uploaddiv);
        _uploaddiv = $$("div", { "className": "UD_SYVCOF" }, _panel);
        _panel_one = $$("div", { "className": "UD_SYVCOFL" }, _uploaddiv);
        $$("img", { "title": "点击查看", "onerror": U.M.ImgError, "src": U.M.GetImgU(US.userInfo.UserThumbnailImageHead), "onclick": [[U.M.StopBubble], [U.U.I.ViewOtherUserInfo, [US.userInfo.userid]]] }, _panel_one);
        $$("div", { "className": "UD_SYVCOFR", "innerHTML": US.userInfo.UserNickName }, _uploaddiv);

        _uploaddiv = $$("div", { "className": "UD_SYVCOS UTDF" }, _panel);
        $$("div", { "className": "UD_SYVCOSN", "innerHTML": "准备上传" }, _uploaddiv);
        $$("div", { "className": "UD_SYVCOSI UD_SYID" }, _uploaddiv);
        _panel_one = $$("div", { "className": "UD_SYVCOC UD_SYVCOX", "title": "等待响应..." }, _uploaddiv);
        $$("img", { "src": US.ms + "img/ULG.gif" }, _panel_one);
        $$("div", { "className": "UD_SYVCOX", "titlle": "点击撤销删除上传", "innerHTML": "撤销", "onclick": [[U.Dk.UP.XWPSCWJ, [_uploaddiv, uploadfiles[i]]]] }, _panel);
        uploadfiles[i]["JD"] = $$("div", { "className": "UD_SYVCOU" }, _uploaddiv);
    }
    _uploadcontent.append(_frag);
}

/**
* 上传文件处理
* @param  {array}  文件所在全局变量U.Dk.UP.FTF["FL"]的位置
* @param  {array}  文件所在全局变量U.Dk.UP.FTF["FL"]中的其中一个的文件集合数组的位置
* @param  {array}  需要上传的文件信息
*/
U.Dk.UP.XWPOPX = function (allfilesnum, filesnum, uploadfiles) {
    try {
        //判断文件是否可以上传，如果可以就调用flash上传接口
        if (U.Dk.UP.ISFLUP(uploadfiles) === true) {
            uploadfiles.LO = "yes"; //设置文件正在上传的说明
            uploadfiles["SO"].UpLoad(allfilesnum, filesnum, uploadfiles.FID); //调用flash的上传接口
        }
        //否则这里直接删除该文件的删除
        else {
            //获取删除按钮,执行点击事件，删除
            var _child = $(uploadfiles["UDOD"]).childg(0, 0).Child();
            _child[_child.length - 1].onclick();
        }
    }
    catch (e) {
        U.Dk.UP.XWPSCWJ(uploadfiles.UDOD, uploadfiles);
        U.Alert("添加文件错误，请重新上传");
    }
}

/**
* 上传文件获取文件流后的处理 
* @param  {string} 文件的md5值
* @param  {string}  需要上传的文件的唯一识别id
*/
U.Dk.UP.XWPOPL = function (md5, fileid) {
    var _tempname, //临时文件上传到临时文件或者是临时图片的名字
        _groupid = "", //文件对应的群id
        _permitdir, //网盘上传的时候需要判断权限,获取权限的上传id等
        _fileinfo = U.Dk.UP.XWPSCWZC(fileid)[2], //获取上传文件所在的位置
        _diskinfo = _fileinfo.UGE, //获取用户操作的网盘信息
        _isimg = U.UP.IsImg(_fileinfo.type.substr(1)); //判断文件的后缀是否为图片

    //在网盘中上传生成链接处理
    if (!_fileinfo["UFN"]["URL"]) {

        _permitdir = U.Dk.HP.WPCZQXHQ(_fileinfo.ID, _diskinfo)[0]; //获取上传目录的权限信息
        _permitdir = _permitdir[_permitdir.length - 1]; //该目录归属的一级目录 包含 我的ftp 我的电脑 我的图片等

        //下面获取用户的群id
        if (_permitdir.UserDirectoryID == US.SG) { //私密空间处理群id
            _groupid = "true";
        }
        else if (_permitdir.UserDirectoryID == US.FG) { //ftp处理
            _groupid = _diskinfo[1][2];
        }
        else if (_permitdir.GroupID) { //群文档处理
            _groupid = _permitdir.GroupID;
        }

        //生成网盘上传链接
        _fileinfo.URL = "http://main.1473.cn/USupfile.ashx?iframename=UploadFlashfile&DirectoryId=" + _fileinfo.ID + "&Encrypt=" + _groupid; //上传地址
    }
    //临时文件上传
    else {
        _tempname = _isimg ? "临时图片" : "临时文件";
        _fileinfo.ID = ""; //上传目录的ID
    }
    //根据用户的md5值判断用户是否需要上传，如果需要上传则需要执行上传处理，如果已经存在后台直接给用户生成文件路径等录入数据库
    U.A.Request(US.Auth, ["IfFileExistInsertDB", _fileinfo.ID, _groupid, _fileinfo.size, md5, _fileinfo.type.substr(1), _fileinfo.name]), U.Dk.UP.AsynXWPOPL, ["", _fileinfo]; //判断上传文件是否存在
}

/**
* 获取文件流异步 
* @param  {object} 用md5去判断上传的文件是否需要上传
*/
U.Dk.UP.AsynXWPOPL = function (r) {
    var _userid = US.userInfo.userid, //当前登录用户的id
        context = r.context, //异步的传参
        _fileinfo = context[1], //上传文件的信息
        _filenum = U.Dk.UP.XWPSCWZC(_fileinfo.FID); //根据文件的id获取在U.Dk.UP.FTF["FL"]中的位置及在U.Dk.UP.FTF["FL"][i]中的位置
    r = r.value;

    //获取服务器返回的值,如果服务器响应出问题了，eval的时候就会报错。
    try {
        r = eval(r)[0];
    }
    catch (e) {

    }
    //当用户想上传的文件已经在数据库里存在了，那么后台会执行复制数据的操作。
    if (r) {
        U.Dk.UP.XWPTJ(r, _fileinfo);
    }
    //否则调用flash里面的函数执行用户的上传操作。
    else {
        fileinfo["SO"].URRUP(fileinfo["URL"] + "&UserId=" + _userid + "&IsF=true", _fileinfo.FID, _filenum[0], _filenum[1]);
    }
}

/**
* 上传文件进度条处理 
* @param  {object} 进度条的值 Loaded 现在的进度  Total 中进度
* @param  {object} 上传文件的唯一识别id
* @param  {object} 用md5去判断上传的文件是否需要上传
*/
U.Dk.UP.XWPJDT = function (progress, fileid, msg) {
    var _fileinfo = U.Dk.UP.XWPSCWZC(fileid)[2], //根据上传文件唯一识别的id获取上传文件的信息
        _progresschilds = $(_fileinfo["UDOD"]).childg(0, 0).childg(0, 3).Child(), //获取上传文件进度条元素
        _progress = Math.floor((progress["Loaded"] / progress["Total"]) * 100); //获取进度的百分比

    _progresschilds[0].innerText = msg; //上传信息提醒，包括准备上传、正在解析、上传中
    _fileinfo["JD"].style.width = _progress + "%"; //上传的进度样式
    _progresschilds[1].style.display = "none"; //上传成功后的√
    _progresschilds[2].style.display = "block"; //loading
}

//文件单个上传完毕
U.Dk.UP.XWPCB = function (uploadfiles) {
    //  U.Alert("文件已传输,等待服务器响应...");
}

/**
* 上传文件成功返回上传文件值 
* @param  {object} 获取服务器返回值
* @param  {string} 上传文件的唯一识别id
*/
U.Dk.UP.XWPCBC = function (r, fileid) {
    var _data = r.data,  //获取服务器返回值
    _fileinfo = U.Dk.UP.XWPSCWZC(fileid); //根据文件的唯一识别id获取文件的信息

    //获取从服务器获取的值，这里加一个错误处理，因为如果后台出现了错误，那么eval的过程就会失败
    try {
        _data = eval("0," + _data);
    }
    catch (e) {

    }
    //文件上传成功
    if (_data) {
        U.Dk.UP.XWPTJ({
            "UserFilesServerName": _data[0], //上传成功后存在fs.1473.cn的地址
            "UseFilesServerThumbnailName": _data[1], //如果是图片上传，那么这里有缩略图的地址
            "UserFilesID": _data[2], //文件在数据的id
            "size": _data[3], //文件的大小
            "UserDirectoryEncrypt": _data[4], //文件的加密情况，这里和分组id是一样的
            "UserDirectoryParentID": _data[5] //文件归属的目录id
        }, _fileinfo[2]);
    }
}

/**
* 上传成功直接添加 
* @param  {object} 获取服务器返回值
* @param  {string} 上传文件的唯一识别id
*/
U.Dk.UP.XWPTJ = function (uploadinfo, uploadfile) {
    var _userinfo = US.userInfo, //上传用户的信息
    _diskinfo = uploadfile.UGE, //上传到指定网盘的用户网盘数据
    _currentdisk = US.Disk.UserDisk,  //当前使用的网盘数据
    _extendtype = uploadfile.type.substr(1), //上传文件的后缀名
    _img = uploadinfo.UseFilesServerThumbnailName, //上传文件展示到网盘的图片
    _groupid = uploadinfo.UserDirectoryEncrypt.length == 36 ? uploadinfo.UserDirectoryEncrypt : "",
    //上传文件成功后，由前端的数据结构生成一个数据实体,实际传参请参考函数里面的数据结构
    _fileinfo = new U.Dk.M.Entity(
                            uploadinfo.UserFilesID, //上传文件的id
                            uploadfile.size,  //上传文件的大小
                            uploadfile.ID,  //上传文件对应的目录id
                            uploadfile.name.addEllipsis(20), //上传文件的简写名
                            uploadfile.name, //上传文件的名字
                            _extendtype, //上传文件的后缀
                            uploadinfo.UserFilesServerName, //上传文件的服务器地址
                            U.MT.toTimeStamp(new Date()), //上传文件成功的时间
                            _img ? _img : U.UP.FFT(_extendtype)[1], //上传文件展示到网盘的图片
                            9999, //上传文件的层次，这里文件是没有层次的，所以以9999区表达
                            null, //文件的修改时间
                            uploadinfo.UserDirectoryEncrypt, //上传文件的加密或者是限制
                            1, //标识该文件在网盘中识别为文件
                            "", //上传文件的描述
                            _groupid, //归属的群id
                            "", //uw office内容
                            _userinfo.UserId, //归属用户的id
                            _userinfo.UserNickName, //归属用户的名字
                            _userinfo.UserName, //归属用户的用户名
                            _userinfo.UserThumbnailImageHead //归属用户的头像
    );
    //如果是上传到网盘的处理
    if (_diskinfo) {
        //添加文件到网盘 0是以数组形式展示所有的文件
        _diskinfo[0].push(_fileinfo);
        //添加文件到网盘 1是以object形式展示所有的文件
        _diskinfo[4][_fileinfo.UserDirectoryID] = _fileinfo;
        //判断是否有上级目录，这里是在上级目录中添加一个child孩子节点，把上传的文件添加到目录中
        if (_diskinfo[4][uploadfile.ID]) {
            if (!_diskinfo[4][uploadfile.ID].Child) {
                _diskinfo[4][uploadfile.ID].Child = []
            }
            _diskinfo[4][uploadfile.ID].Child.push(_fileinfo);
        }
        //设置用户网盘的信息
        _diskinfo[1][0].FilesCount += 1; //文件数
        _diskinfo[1][0].FileSize += uploadfile.size; //文件大小

        //添加成功后，显示在网盘中
        U.Dk.RE.AsynWPJQ(_diskinfo[1][2], [_fileinfo], null, true)

    }
    U.Dk.UP.XWPSCWJ(uploadfile["UDOD"], uploadfile); //单个文件上传成功后，排队让下一个文件执行，同时销毁刚刚上传的文件

}

/**
* 移除当前上传元素，排队向下上传处理
* @param  {element} 需要移除的元素
* @param  {object} 上传文件的信息
*/
U.Dk.UP.XWPSCWJ = function (uploadel, uploadfile) {
    var i, j, _UAE,
    _allfiles = U.Dk.UP.FTF["FL"],
    _fileinfo = U.Dk.UP.XWPSCWZC(uploadfile.FID), //根据文件的id获取在U.Dk.UP.FTF["FL"]中的位置及在U.Dk.UP.FTF["FL"][i]中的位置
    _allfilesnum = _fileinfo[1], //文件在U.Dk.UP.FTF["FL"]中的位置
    _filesnum = _fileinfo[0]; //文件在U.Dk.UP.FTF["FL"][i]中的位置
    $(uploadel).remove(); //上传成功后删除上传的元素
    if (_filesnum != -1) { //实体存在

        //移除一个上传文件
        _allfiles[_allfilesnum].splice(_filesnum, 1)[0];

        //如果在移除的文件是该多个flash上传中的其中一个的最后一个上传，那么直接删除上传数组
        if (!_allfiles[_allfilesnum].length) {
            _allfiles.splice(_allfilesnum, 1);

        }
        uploadfile["SO"].DF(_filesnum, _allfilesnum); //flash中删除上传。


        //判断上传文件的上传状态，如果是正在上传的文件删除，那么需要向下执行上传文件
        if (uploadfile["LO"]) {
            //如果还有文件需要上传
            if (_allfiles.length) {

                //利用排队的方式执行文件上传
                for (i = 0; i < _allfiles.length; i++) { //从所有的上传文件数组里排队

                    for (j = 0; j < _allfiles[i].length; j++) { //在fileslist中排队筛选
                        if (!_allfiles[i][j]["LO"]) { //如果该文件的状态没有在上传中，那么就直接上传
                            U.Dk.UP.XWPOPX(j, i, _allfiles[i][j]); //调用上传处理
                            break;
                        }
                    }
                }
            }
            else {
                U.Dk.UP.XWPGBSC(); //清空上传框
            }
        }
    }
}

/**
* 清空上传框处理
*/
U.Dk.UP.XWPGBSC = function () {
    var _flashinfo = U.Dk.UP.FTF["FL"]; //flash的信息
    if (_flashinfo.length && _flashinfo[0][0]) {
        $("#UD_SYVC")[0].innerText = ""; //清空上传
        _flashinfo[0][0]["SO"].DAF(); //调用flash执行flash的停止上传的处理
    }
}

/**
* 获取上传文件所在的位置
* @param  {object}  错误消息
* @return  {array}  上传文件的位置及信息
*           0 上传文件在一个flashfiles的位置
*           1 上传文件在多个flashfiles中其中一个flashfiles的位置
*           2 找到上传文件的信息
*/
U.Dk.UP.XWPOPC = function (errorinfo) {
    if (errorinfo.message) {  //有错误消息
        var _meeage = "上传处理失败：" + errorinfo.message; //上传错误信息
        if (UE.errorID == 1502) { //当错误编码是1502时候我们弹出用户可理解的错误
            _meeage = "文件太大，电脑内存不足";
        }
        U.Alert(_meeage); //弹出错误
        U.M.Console(UE); //控制台输出错误
    }
}

//
/**
* 获取上传文件所在的位置
* @param  {string}  上传文件的id
* @return  {array}  上传文件的位置及信息
*           0 上传文件在一个flashfiles的位置
*           1 上传文件在多个flashfiles中其中一个flashfiles的位置
*           2 找到上传文件的信息
*/
U.Dk.UP.XWPSCWZC = function (fileid) {
    var i, j,
    _allfiles = U.Dk.UP.FTF["FL"]; //用户需要上传的所有文件
    for (i = 0; i < _allfiles.length; i++) {
        j = _allfiles[i].objIndexOf({ "FID": fileid }); //根据FID在_allfiles[i]数组的查找获取FID = fileid的上传文件信息
        //找到该上传文件
        if (j > -1) {
            /*
            *           0 上传文件在一个flashfiles的位置
            *           1 上传文件在多个flashfiles中其中一个flashfiles的位置
            *           2 找到上传文件的信息
            */
            return [j, i, _allfiles[i][j]];
        }
    }
    return [-1, -1, null]; //返回未找到的信息
}

/**
* 文件判断是否允许上传 包含是否超过最大上传文件的大小和上传文件已经个超过用户网盘使用大小
* @param  {object}  上传文件的信息
* @return  {boolean||number}  返回上传信息
*           true  该文件可以上传
*           1 上传文件大于单个文件最大数
*           2 网盘已满
*/
U.Dk.UP.ISFLUP = function (uploadfile) {
    var _diskinfo = uploadfile.UGE;
    //判断文件的大小是否超过2G
    if (uploadfile["size"] > U.UP.GetSfileS("2G")) {
        U.Alert("最大上传文件不可以超过2G");
        return 1;
    }
    //判断上传文件后网盘会不会超出总大小
    else if ((U.UP.GetSfileS(US.userInfo.FileSize + "B") + uploadfile.size) >= U.UP.GetSfileS(US.userInfo.UserDiskSpace + "M")) {
        U.Alert("你的网盘已满，请用积分兑换网盘空间");
        return 2;
    }
    return true;
}

//#endregion