webserviced.htc

浏览器端看到树型目录结构,用户可以完整地看到像windows资源管理器一样的效果

    {
    case 1 :
        sz = argVal;
        break;
    case 2 :
        sz = "<![CDATA[" + argVal + "]]>";
        break;
    case 3 :
        try
        {
            sz  =   argVal.getFullYear()
                +   "-" + fixupDT(argVal.getMonth() + 1)
                +   "-" + fixupDT(argVal.getDate())
                +   "T" + fixupDT(argVal.getHours())
                +   ":" + fixupDT(argVal.getMinutes())
                +   ":" + fixupDT(argVal.getSeconds())
                +   (argVal.getMilliseconds==null
                            ? '' : ('.' + argVal.getMilliseconds()))
                +   encTZ(argVal);
        }
        catch (e) { sz = argVal; }
        break;
    case 4 :
        try
        {
            sz  =   argVal.getFullYear()
                +   "-" + fixupDT(argVal.getMonth() + 1)
                +   "-" + fixupDT(argVal.getDate())
                +   encTZ(argVal);
        }
        catch (e) { sz = argVal; }
        break;
    case 5 :
        try
        {
            sz  =   fixupDT(argVal.getHours())
                +   ":" + fixupDT(argVal.getMinutes())
                +   ":" + fixupDT(argVal.getSeconds())
                +   (argVal.getMilliseconds==null
                            ? '' : ('.' + argVal.getMilliseconds()))
                +   encTZ(argVal);
        }
        catch (e) { sz = argVal; }
        break;
    case 6 :
    case 7 :
        sz = encb64(argVal);
        break;
    default :
        sz = argVal;
    }
    return sz;
}

//
// build Jscript array based on array size info and array dimension
//  a[in,out]   : jscript array to be built
//  as[in]      : array size array
//  d[in]       : dimension
//

function bldJsAry(a, as, d)
{
    if (d == as.length-1)
        return;
    for (var i = 0; i < as[d]; i++)
    {
        a[i] = new Array();
        bldJsAry(a[i], as, d+1)
    }
}

//
// get the next array index following the last one passed in (ai)
//  a[in]       : array size array that holds array size information (5,5,5)
//  ai[in,out]  : previous index, we need to return the one next to it
//                (1,3,4)'s next is (1,4,0)
//  return      : ai (byref), boolean : true if successful, false otherwise
//

function getNextIndexAry(a, ai)
{
    var i;
    var l = a.length;
    if (ai.length == 0)
    {
        for (i = 0; i < l; i++)
            ai[i] = 0;
        return true;
    }
    for (i = l - 1; i >= 0; i--)
    {
        if (i == 0 && 1 + ai[0] > a[0] - 1)
            return false;
        var x = ai[i] + 1;
        if (x <= a[i] - 1)
        {
            ai[i] = x;
            return true;
        }
        ai[i] = 0;
    }
    return true;
}

//
// transform a VB array to a jscript array
// a[in]    : vb array
// d[in]    : vb array depth
// return   : jscript array
//
function vbArrayToJs(a, d)
{
    //
    // create vb array accessor function for the specified depth
    //

    ensureVBArray(d);
    var szSize;

    //
    // get vb array size information in string format, ex. "2,3,4"
    //

    try { szSize = VBGetArySize(a, d); } catch (e) {return new Array()}
    var aSize = szSize.toString().split(",");
    var aszIndex = new Array();
    var ajs = new Array();

    //
    // prebuild jscript array
    // we will fill this array later using eval, because we can't access
    // vb array items
    //

    bldJsAry(ajs, aSize, 0);

    //
    // create array index array, ex. (1,2,3) to access that item in multiD
    // aSize holds the size array for the multi-D array
    // iterate all array items, do an eval like this:
    // eval("ajs[i][j][k] = VBGetAryItemN(a, i, j, k);")
    // note: N is the dimension of the array
    //

    var ai = new Array();
    while (true == getNextIndexAry(aSize, ai))
    {
        var s = "ajs["+ai.join("][")+"]=VBGetAryItem"+d+"(a,"+ai.join(",")+");";
        try { eval(s);} catch (e) {break;}
    }
    return ajs;
}

//
// encode array of elements (transform script array to XML encoded)
//

function encodeArray(os, t, nt, v, d)
{
    var sz = "";
    for (var i in v)
    {
        if (d == 1)
        {
            var ar = encodeVar(os, v[i], nt);
            xt = ' xsi:type="' + (t.ns ==''?'':(t.ns + ':'))+t.type+'"';
            sz += '\n<' + t.type + ar[1] +xt+'>' + ar[0] + '</' + t.type + '>';
        }
        else
            sz += encodeArray(os, t, nt, v[i], d-1);
    }
    return sz;
}

function encodeVar(oS, v, t)
{
    dbgPrint("encoding " + printObject(v, 'val=') + " (TYPE=" + t.type + ")\n");
    var ar = new Array("", "");
    if (v == null)
        return ar;
    var oschm = getSchema(oS, t);
    var ae = t.fArray ? t : getAryElem(os, oschm, t);
    if (ae != null)
    {
        dbgPrint("encoding array " + ae.name + "\n");
        if (typeof v != 'object' && typeof v != 'unknown')
            return ar;
        var nt = cloneObject(ae);
        nt.fArray = false;
        var sArr = ae.sizeArray;
        var k = 1;
        k = (sArr == null) ? 1 : sArr.length;
        if (typeof v == 'unknown')
            v = vbArrayToJs(v, k);
        ar[0] += encodeArray(oS, ae, nt, v, k);
        return ar;
    }
    if (isSimpleType(oS, oschm, t))
    {
        ar[0] = encodePrimitive(oS, t.type, v);
        return ar;
    }

    var et = oschm.types[t.type];
    if (et == null)
    {
        dbgPrint(t.type + ' is null or any \n');
        try
        {
            var os = v.childNodes;
            for (var i = 0; i < os.length; i ++)
            {
                ar[0] += os[i].xml;
            }
        }
        catch (e)
        {
            ar[0] += v;
        }
        return ar;
    }
    if (typeof v != 'object' || v.length > 0)
    {
        dbgPrint("argument is an array\n");
        var et1 = get1stAryItem(et);
        if (et1 == null)
            return ar;
        return encodeVar(oS, v, et1)
    }
    for (var k in et)
    {
        dbgPrint("encoding " + k + "\n");
        //dbgPrintObject(et[k], k);
        //dbgPrintObject(v[k], k);
        if (et[k] == null)
            continue;
        if (v[k] == null)
        {
            if (!et[k].fAttrib)
                ar[0] += '\n<' + et[k].name + ' xsi:null="true"' + '/>\n';
            continue;
        }
        if (et[k].fAttrib)
        {
            ar[1] += encodeAttrib(oS, v[k], et[k]);
            continue;
        }

        var qt = "";
        var asi = "";
        var it = getAryElem(oS, getSchema(oS, et[k]), et[k]);
        var soapencns = oS.qlt["soapenc"];
        if (it != null)
        {
            asi = getArySizeInfo(it, v[k]);
            var ts = (isPrimitive(oS, it) || et[k].ns == "")
                        ? "xsd:" : (et[k].ns + ":");
            asi = ' xsi:type="' + soapencns + ':Array" '
                + soapencns + ':arrayType="' + ts + it.type+'['+ asi +']"';
        }
        else if (isPrimitive(oS, et[k]))
            qt = ' xsi:type="xsd:' + et[k].type + '"';
        var ark = encodeVar(oS, v[k], et[k]);
        ar[0] += '\n<' + et[k].name + qt + asi + ark[1] + '>'
            + ark[0] + '</' + et[k].name + '>';
    }
    return ar;
}

//
// get array size, taking care of associative arrays
//
function getArySize(a)
{
    var l = 0;
    for (var x in a)
        l++;
    return l;
}

//
// get first item of an array
//
function get1stAryItem(a)
{
    for (var x in a)
        return a[x];
    return null;
}

function getAryItemFromIndex(a, index)
{
    var i = 0;
    for (var x in a)
    {
        if (i == index)
            return a[x];
        i++;
    }
    return null;
}

//
// retrieve the type schema
//
function getSchema(os, t)
{
    if (isPrimitive(os, t))
        return null;
    if (t.ns==null)
        return get1stAryItem(os.schemas);
    var nsUrl = os.ns[t.ns];
    var oschm = os.schemas[nsUrl];
    if (oschm != null || t.ns.length == 0)
        return oschm;
    for (var x in os.schemas)
        if (x.indexOf(nsUrl) == 0 && os.schemas[x].types[t.type] != null)
            return os.schemas[x];
    return null;
}

//
//  get array size info from either argument type or argument itself
//  at[in]  : array type
//  av[in]  : array value
//  return  : array size, or string like "2, 4, 5" for multi-dimensional array
//
function getArySizeInfo(at, av)
{
    var as = at.sizeArray;
    var k = 1;
    k = (as == null) ? 1 : as.length;
    var arr = av;
    if (typeof arr == 'unknown')
        arr = vbArrayToJs(arr, k);
    var sArr = getArySize(arr);
    if (as == null)
        return sArr;
    sArr = "";
    for (var j = 0;;)
    {
        var l2 = getArySize(arr);
        if (as[j] == null)
            sArr+=l2;
        else
            sArr+=Math.min(as[j], l2);
        j = j + 1;
        if (j == as.length)
            break;
        sArr += ",";
        if (l2 == 0)
            return null;
        arr = get1stAryItem(arr);
    }
    return sArr;
}

//
// serialize attributes
//

function encodeAttrib(oS, v, t)
{
    if (t.type == null)
        return "";
    return " " + t.name + '="' + encodePrimitive(oS, t.type, v) + '"';
}

//
// serialize a message part
// oS[in] : service
// oM[in] : method
// a[in] : part definition
// v[in] : part variable to be serialized
//

function serPart(oS, oM, a, v)
{
    var sz = "";
    var szt = '';
    if (a.type!=null && isPrimitive(oS, a))
        szt = ' xsi:type="xsd:' + a.type + '"';
    var oschm = getSchema(oS, a);
    var aryItem = a.fArray ? a : getAryElem(oS, oschm, a);
    var soapencns = oS.qlt["soapenc"];
    if (aryItem != null)
    {
        var sArr = getArySizeInfo(aryItem, v);
        //
        // fixup namespace for illformed wsdl files
        // that use parent namespace (phalanx)
        //
        var oschm = getSchema(oS, aryItem);
        if (oschm != null)
            aryItem.ns = oS.nsalias[oschm.uri];
        var ts = (isPrimitive(oS, aryItem) || aryItem.ns == "")
                ? "xsd:" : (aryItem.ns + ":");
        szt = ' xsi:type="' + soapencns + ':Array" '
            + soapencns + ':arrayType="'+ts+aryItem.type+'['+sArr+']"';
    }
    else
        szt = ' xsi:type="' + (a.ns == '' ? '' : (a.ns + ':'))+a.type+'"';

    et = (a.elem == null || oschm == null) ? a : oschm.elems[a.elem];

    var ar = encodeVar(oS, v, et);
    if (oM.fLiteral)
    {
        if (a.elem == null)
        {
            if (oM.fWrapped || oM.fRpc)
            {
                sz += '\n<' + a.name + ar[1] + '>' + ar[0];
                sz += '</' + a.name + '>';
            }
            else
                sz += ar[0];
        }
        else
        {
            var ns=' xmlns="'+(a.ns==null?oS.targetns:oS.ns[a.ns])+'"';
            sz += '\n<' + a.elem + ns + ar[1] + '>' + ar[0];
            sz += '</' + a.elem + '>';
        }
    }
    else
    {
        // this shouldn't happen according to WSDL spec
        // however, some wsdl files still doesn't have a type
        if (a.type == null)
            a.type = a.elem;
        var stn = 'mswsb:' + (oM.fRpc ? et.name : et.type);
        stn = aryItem == null ? stn : (soapencns + ":Array");
        n = "";
        if (oM.fWrapped || oM.fRpc && oM.opname != null)
            stn = a.name;
        else if (aryItem == null)
            n =' xmlns:mswsb="'+(a.ns==null?oS.targetns:oS.ns[a.ns])+'"';
        sz += '\n<' + stn + n + szt + ar[1] + '>' + ar[0];
        sz += '</' + stn + '>';
    }
    return sz;
}

//
// get part wrap
//

function getWrap(aWrap, oS, oM, argv)
{
    if (!oM.fRpc && !oM.fWrapped)
        return argv;
    var mn = oM.opname;
    var pns = oM.fLiteral ? "" : "mswsb:";
    var nsq1 = oM.ns;
    if (!oM.fRpc)
    {
        var firstArg = get1stAryItem(argv);
        var oschm = getSchema(oS, firstArg);
        if (firstArg.type != null)
        {
            argv = oschm.types[firstArg.type];