TypeScript ConfigUtil.addSytacticSuffix函數代碼示例

export async function deliverStream(sponsor: PluginBase,
    config: GmeConfig.GmeConfig, payload: string): Promise<GmeClasses.Result> {
    sponsor.logger.info("deliver multipart/form-data to URI");

    if (!config.hasOwnProperty("deliveryUrl")) {
        return Promise.reject(new Error("No uri provided."));
    }
    let configDictionary: any = config;

    try {
        let fileName = await addSytacticSuffix(config, configDictionary["topic"]);

        let form = new FormData();
        form.append("filename", payload, {
            filename: fileName,
            contentType: "text/plain",
            knownLength: payload.length
        });
        sponsor.logger.info(`payload being written: ${fileName}`);
        let uri = configDictionary["deliveryUrl"];
        form.submit(uri, (_error: any, response: any): void => {
            response.resume();
        });
        sponsor.sendNotification(`payload ${fileName} written`);
        sponsor.result.setSuccess(true);
        sponsor.sendNotification("resolved");
        return Promise.resolve(sponsor.result);
    }
    catch (err) {
        sponsor.sendNotification(`problem writing url: ${err.message}`);
        return Promise.reject(err.message);
    }
}

export async function deliverFile(sponsor: PluginBase, config: GmeConfig.GmeConfig, payload: string): Promise<GmeClasses.Result> {
    sponsor.logger.info(`deliver file of size: ${payload.length}`);

    let configDictionary: any = config;
    if (!configDictionary.hasOwnProperty("topic")) {
        return Promise.reject(new Error("No file name provided."));
    }
    sponsor.sendNotification("config has property");

    try {
        let targetFileName = await addSytacticSuffix(config, configDictionary["topic"]);
        fs.ensureFileSync(targetFileName);
        let fileName = targetFileName;

        sponsor.logger.info(`file being written: ${fileName} in ${process.cwd()}`);
        fs.writeFileSync(fileName, payload);
        sponsor.sendNotification(`file ${fileName} written`);
        sponsor.result.setSuccess(true);
        return Promise.resolve(sponsor.result);
    }
    catch (err) {
        sponsor.sendNotification(`problem writing file: ${err.message}`);
        return Promise.reject(err.message);
    }
}

export async function deliverArtifact(sponsor: PluginBase, config: GmeConfig.GmeConfig, payload: string): Promise<GmeClasses.Result> {

    let configDictionary: any = config;
    sponsor.logger.info("deliver artifact");

    if (!configDictionary.hasOwnProperty("topic")) {
        return Promise.reject(new Error("No file name provided."));
    }
    sponsor.sendNotification("config has property");

    try {
        let artifactName = "stream-";
        switch (configDictionary["schematicVersion"]) {
            case "schema-tree:1.0.0":
                artifactName += "schema-tree";
                break;
            case "schema-flat:1.0.0":
                artifactName += "schema-flat";
                break;
            case "model-tree:1.0.0":
                artifactName += "model-tree";
                break;
            case "model-flat:1.0.0":
                artifactName += "model-flat";
                break;
        }
        let artifact = await sponsor.blobClient.createArtifact(artifactName);

        sponsor.sendNotification("artifact created");
        let pushedTopic = addSytacticSuffix(config, configDictionary["topic"]);


        sponsor.sendNotification(`adding: ${pushedTopic}`);
        let hash = await artifact.addFile(pushedTopic, payload);

        sponsor.sendNotification(`saving: ${hash}`);
        let reHash = await artifact.save();

        sponsor.sendNotification(`adding artifact: ${reHash}`);
        sponsor.result.addArtifact(reHash);
        sponsor.result.setSuccess(true);
        sponsor.sendNotification("resolution");
        return Promise.resolve(sponsor.result);
    } catch (err) {
        sponsor.sendNotification(`problem in file delivery: ${err.message}`);
        return Promise.reject(err.message);
    }
}

export async function deliverSinglepart(sponsor: PluginBase,
    config: GmeConfig.GmeConfig, payload: string): Promise<GmeClasses.Result> {
    sponsor.logger.info("deliver single-part to URI");

    if (!config.hasOwnProperty("deliveryUrl")) {
        return Promise.reject(new Error("No uri provided."));
    }
    let configDictionary: any = config;

    let fileName = addSytacticSuffix(config, configDictionary["topic"]);
    let deliveryUrl = configDictionary["deliveryUrl"];
    try {
        let urlMap = await url.parse(deliveryUrl);
        let postOptions: http.RequestOptions = {
            method: "POST",
            headers: {
                "Content-Type": "text/plain",
                "Content-Disposition": `attachment; filename=${fileName}`,
                "Content-Length": Buffer.byteLength(payload)
            },
            hostname: urlMap.hostname,
            port: Number(urlMap.port),
            path: urlMap.path
        };
        let postReq = http.request(postOptions, (res) => {
            res.setEncoding("utf8");
            res.on("data", (chunk: any) => {
                console.log(`Response: ${chunk}`);
            });
        });
        await postReq.write(payload);
        postReq.end();

        sponsor.sendNotification(`payload written to ${deliveryUrl} as ${fileName}`);
        sponsor.result.setSuccess(true);
        sponsor.sendNotification("resolved");
        return Promise.resolve(sponsor.result);
    } catch (err) {
        sponsor.sendNotification(`problem writing payload to url: ${err.message} as ${fileName} `);
        return Promise.reject(err.message);
    }
}