Signature verification failed

Signature verification failed - solana

Please help, when executing this function, an error about the signature comes out
export const UseMetaplexProvider = () => {
const { connection } = useConnection();
const wallet = useWallet();
return useMemo(
() =>
Metaplex.make(solanaConnection)
.use(walletAdapterIdentity(wallet))
.use(
bundlrStorage({
address: "https://devnet.bundlr.network",
// providerUrl: endpoint,
timeout: 60000,
})
),
[solanaConnection, wallet]
);
};
const { uri } = await metaplex.nfts().uploadMetadata({
name: "Test Token",
symbol: "TEST",
description: "This is a test token!",
image:
"https://bipbap.ru/wp-content/uploads/2017/04/0_7c779_5df17311_orig.jpg", //add public URL to image you'd like to use
});
console.log("URI", uri);
console.log("METADATA", metadata);
I tried using metaplex.identity().signMessage(). But it still didn't help

Related

Redis - The client is closed

I want to save a token in the redis cache after user sign-in in my app.
The cache config.service.ts file:
#Injectable()
export class CacheConfigService {
constructor(private configService: ConfigService) {}
get url(): string {
console.log(this.configService.get<string>('redis.url'));
return this.configService.get<string>('redis.url') as string;
}
}
The cacheModule file:
#Module({
imports: [
CacheModule.register<RedisClientOptions>({
// #ts-ignore
store: createRedisStore,
socket: {
host: 'localhost',
port: 6379,
},
isGlobal: true,
// url: 'redis://' + process.env.REDIS_HOST + ':' + process.env.REDIS_PORT,
}),
],
})
The user signin method:
emailPasswordSignInPOST: async (input: any) => {
if (
originalImplementation.emailPasswordSignInPOST === undefined
) {
throw Error('Should never come here');
}
let response: any =
await originalImplementation.emailPasswordSignInPOST(input);
const formFields: any = input.formFields;
const inputObject: any = {};
for (let index = 0; index < formFields.length; index++) {
const element = formFields[index];
inputObject[element.id] = element.value;
}
const { email } = inputObject;
const user = await this.userService.findOneByEmail(email);
const id = user?.id;
const payload = { email, id };
const secret = 'mysecret';
const token = jwt.sign(payload, secret, {
expiresIn: '2h',
});
response.token = token;
const cacheKey = 'Token';
await this.redisClient.set(cacheKey, token, {
EX: 60 * 60 * 24,
});
return response;
},
Please note that this is a different module.
When I send signin request from postman than it logs this error in the console: "Error: The client is closed"
I ran the app with the command DEBUG=* npm run start:dev to see the logs about redis but there is no log about redis.

Unable to upload file graphql urql

I got empty object while uploading image. I follow all the step provided, but still can't make it solve. The error said "Variable "$file" got invalid value {}; Upload value invalid."
const client = createClient({
url: import.meta.env.VITE_BASE_API_URL ?? '',
exchanges: [
...defaultExchanges,
dedupExchange,
cacheExchange,
subscriptionExchange({
forwardSubscription: (operation) => ({
subscribe: (sink) => ({
unsubscribe: wsClient.subscribe(operation, sink),
}),
}),
}),
refocusExchange(),
multipartFetchExchange,
],
});
export const UPLOAD_WORKER_IMAGE = gql`
mutation setImage($file: Upload!, $workerId: UUID!) {
updateWorker(input: { patch: { imageUrl: $file }, id: $workerId }) {
}
}
}
`;
// Upload.tsx
const [, mutateWorkerImage] = useMutation<UpdateWorker>(UPLOAD_WORKER_IMAGE);
const file = bindData.avatarFile;
const { error: errorUploadImage, data } = await mutateWorkerImage({
workerId: dataWorker.createWorker.worker.id,
file: file,
});

Post Error with Apollo Client While Creating a New User

I am running into a POST http://localhost:4000/ 400 (Bad Request) Error.
I am trying to create a new user with the following frontend.
const REGISTER_USER = gql`
mutation Mutation(
$createUser: CreateUserInput!
) {
createUser(createUserInput: $createUserInput){
email
name
token
password
}
}
`
const Register = () => {
const context = useContext(AuthContext)
let navigate = useNavigate()
const [errors, setErrors] = useState([])
function registerUserCallback() {
console.log("Callback hit")
registerUser()
}
const {onChange, onSubmit, values} = useForm(registerUserCallback, {
name: '',
email: '',
password:'',
confirmPassword: '',
})
const [registerUser, {loading}] = useMutation(REGISTER_USER, {
update(proxy, {data: {registerUser: userData}}) {
context.login(userData)
navigate('/Dashboard')
},
onError({graphQLErrors}) {
setErrors(graphQLErrors)
console.log("Error: " + graphQLErrors)
console.log(graphQLErrors)
},
variables: {createUserInput: values}
})
However, the grapQLErrors is not even being console.logged for some reason. When I run the Mutation via Apollo Studio it works. Any information would be great!
Edit: Network Tab Screenshot:
Adding Code for my httpLink:
import { ApolloClient, InMemoryCache, createHttpLink } from "#apollo/client";
import { setContext } from "#apollo/client/link/context";
const httpLink = createHttpLink({
uri: 'http://localhost:4000'
})
const authLink = setContext((_, {headers}) => {
return {
headers: {
...headers,
authorization: localStorage.getItem('token') || ""
}
}
})
export const client = new ApolloClient({
link: authLink.concat(httpLink),
cache: new InMemoryCache()
});
Edit: createUser Mutation seems to be the issue. This is the Network response error: ["GraphQLError: Unknown argument "createUserInput" on field "Mutation.createUser".","
#Mutation((returns) => User)
async createUser(#Arg('data') data:CreateUserInput, #Ctx() ctx: Context) {
const oldUser = await ctx.prisma.user.findFirst({ where: { email: data.email}})
if(oldUser) {
throw new ApolloError('A user is already registered with the email' + data.email, 'USER_ALREADY_EXISTS')
}
var encryptedPassword = await bcrypt.hash(data.password, 10)
const newUser = await ctx.prisma.user.create({
data: {
name: data.name,
email: data.email,
password: encryptedPassword
}
})
return {token: jwt.sign(newUser, 'supersecret')}
}
Here is a screen shot of my Preview in my Network...I really don't get it.
export class CreateUserInput {
#Field((type) => String)
name: string
#Field((type) => String)
email: string
#Field((type) => String)
password: string

The bot name is already registered to another bot application

I had previously tried to deploy this bot and had issues. I attempted to delete the resource group and try again from scratch and am getting this error.
Built with: Bot Framework Composer (v1.1.1)
Deploying with: provisionComposer.js
> Deploying Azure services (this could take a while)...
✖
{
"error": {
"code": "InvalidBotData",
"message": "Bot is not valid. Errors: The bot name is already registered to another bot application.. See https://aka.ms/bot-requirements for detailed requirements."
}
}
** Provision failed **
The link in the error message doesn't mention 'bot name' or 'name'.
Does a bot name have to be unique to the subscription, tenant, etc?
Is there a place I need to go to 'un-register' the bot name so that it can be registered to another application? Was deleting the resource group not enough?
Thanks in advance for the assistance.
Best Regards,
Josh

I ran into the same issue. After some modifications to the script I was able to complete the provisioning of resources. Issue was the name used to create some of the resources did not match because of the environment variable appended.
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
const chalk = require("chalk");
const fs = require("fs-extra");
const msRestNodeAuth = require("#azure/ms-rest-nodeauth");
const argv = require("minimist")(process.argv.slice(2));
const path = require("path");
const rp = require("request-promise");
const { promisify } = require("util");
const { GraphRbacManagementClient } = require("#azure/graph");
const {
ApplicationInsightsManagementClient,
} = require("#azure/arm-appinsights");
const { AzureBotService } = require("#azure/arm-botservice");
const { ResourceManagementClient } = require("#azure/arm-resources");
const readFile = promisify(fs.readFile);
const ora = require("ora");
const logger = (msg) => {
if (msg.status === BotProjectDeployLoggerType.PROVISION_ERROR) {
console.log(chalk.red(msg.message));
} else if (
msg.status === BotProjectDeployLoggerType.PROVISION_ERROR_DETAILS
) {
console.log(chalk.white(msg.message));
} else {
console.log(chalk.green(msg.message));
}
};
const usage = () => {
const options = [
["subscriptionId", "Azure Subscription Id"],
["name", "Project Name"],
["appPassword", "16 character password"],
["environment", "Environment name (Defaults to dev)"],
["location", "Azure Region (Defaults to westus)"],
["appId", "Microsoft App ID (Will create if absent)"],
[
"tenantId",
"ID of your tenant if required (will choose first in list by default)",
],
["createLuisResource", "Create a LUIS resource? Default true"],
[
"createLuisAuthoringResource",
"Create a LUIS authoring resource? Default true",
],
["createCosmosDb", "Create a CosmosDB? Default true"],
["createStorage", "Create a storage account? Default true"],
["createAppInsights", "Create an AppInsights resource? Default true"],
["createQnAResource", "Create a QnA resource? Default true"],
[
"customArmTemplate",
"Path to runtime ARM template. By default it will use an Azure WebApp template. Pass `DeploymentTemplates/function-template-with-preexisting-rg.json` for Azure Functions or your own template for a custom deployment.",
],
];
const instructions = [
``,
chalk.bold(
"Provision Azure resources for use with Bot Framework Composer bots"
),
`* This script will create a new resource group and the necessary Azure resources needed to operate a Bot Framework bot in the cloud.`,
`* Use this to create a publishing profile used in Composer's "Publish" toolbar.`,
``,
chalk.bold(`Basic Usage:`),
chalk.greenBright(`node provisionComposer --subscriptionId=`) +
chalk.yellow("<Azure Subscription Id>") +
chalk.greenBright(" --name=") +
chalk.yellow("<Name for your environment>") +
chalk.greenBright(" --appPassword=") +
chalk.yellow("<16 character password>"),
``,
chalk.bold(`All options:`),
...options.map((option) => {
return (
chalk.greenBright("--" + option[0]) + "\t" + chalk.yellow(option[1])
);
}),
];
console.log(instructions.join("\n"));
};
// check for required parameters
if (Object.keys(argv).length === 0) {
return usage();
}
if (!argv.name || !argv.subscriptionId || !argv.appPassword) {
return usage();
}
// Get required fields from the arguments
const subId = argv.subscriptionId;
const name = argv.name.toString();
const appPassword = argv.appPassword;
// Get optional fields from the arguments
const environment = argv.environment || "dev";
const location = argv.location || "westus";
const appId = argv.appId; // MicrosoftAppId - generated if left blank
// Get option flags
const createLuisResource = argv.createLuisResource == "false" ? false : true;
const createLuisAuthoringResource =
argv.createLuisAuthoringResource == "false" ? false : true;
const createCosmosDb = argv.createCosmosDb == "false" ? false : true;
const createStorage = argv.createStorage == "false" ? false : true;
const createAppInsights = argv.createAppInsights == "false" ? false : true;
const createQnAResource = argv.createQnAResource == "false" ? false : true;
var tenantId = argv.tenantId ? argv.tenantId : "";
const templatePath =
argv.customArmTemplate ||
path.join(
__dirname,
"DeploymentTemplates",
"template-with-preexisting-rg.json"
);
const BotProjectDeployLoggerType = {
// Logger Type for Provision
PROVISION_INFO: "PROVISION_INFO",
PROVISION_ERROR: "PROVISION_ERROR",
PROVISION_WARNING: "PROVISION_WARNING",
PROVISION_SUCCESS: "PROVISION_SUCCESS",
PROVISION_ERROR_DETAILS: "PROVISION_ERROR_DETAILS",
};
/**
* Create a Bot Framework registration
* #param {} graphClient
* #param {*} displayName
* #param {*} appPassword
*/
const createApp = async (graphClient, displayName, appPassword) => {
try {
const createRes = await graphClient.applications.create({
displayName: displayName,
passwordCredentials: [
{
value: appPassword,
startDate: new Date(),
endDate: new Date(
new Date().setFullYear(new Date().getFullYear() + 2)
),
},
],
availableToOtherTenants: true,
replyUrls: ["https://token.botframework.com/.auth/web/redirect"],
});
return createRes;
} catch (err) {
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: err.body.message,
});
return false;
}
};
/**
* Create an Azure resources group
* #param {} client
* #param {*} location
* #param {*} resourceGroupName
*/
const createResourceGroup = async (client, location, resourceGroupName) => {
logger({
status: BotProjectDeployLoggerType.PROVISION_INFO,
message: `> Creating resource group ...`,
});
const param = {
location: location,
};
return await client.resourceGroups.createOrUpdate(resourceGroupName, param);
};
/**
* Format parameters
* #param {} scope
*/
const pack = (scope) => {
return {
value: scope,
};
};
const unpackObject = (output) => {
const unpacked = {};
for (const key in output) {
const objValue = output[key];
if (objValue.value) {
unpacked[key] = objValue.value;
}
}
return unpacked;
};
/**
* For more information about this api, please refer to this doc: https://learn.microsoft.com/en-us/rest/api/resources/Tenants/List
* #param {*} accessToken
*/
const getTenantId = async (accessToken) => {
if (!accessToken) {
throw new Error(
"Error: Missing access token. Please provide a non-expired Azure access token. Tokens can be obtained by running az account get-access-token"
);
}
if (!subId) {
throw new Error(
`Error: Missing subscription Id. Please provide a valid Azure subscription id.`
);
}
try {
const tenantUrl = `https://management.azure.com/subscriptions/${subId}?api-version=2020-01-01`;
const options = {
headers: { Authorization: `Bearer ${accessToken}` },
};
const response = await rp.get(tenantUrl, options);
const jsonRes = JSON.parse(response);
if (jsonRes.tenantId === undefined) {
throw new Error(`No tenants found in the account.`);
}
return jsonRes.tenantId;
} catch (err) {
throw new Error(`Get Tenant Id Failed, details: ${getErrorMesssage(err)}`);
}
};
const getDeploymentTemplateParam = (
appId,
appPwd,
location,
name,
shouldCreateAuthoringResource,
shouldCreateLuisResource,
shouldCreateQnAResource,
useAppInsights,
useCosmosDb,
useStorage
) => {
return {
appId: pack(appId),
appSecret: pack(appPwd),
appServicePlanLocation: pack(location),
botId: pack(name),
shouldCreateAuthoringResource: pack(shouldCreateAuthoringResource),
shouldCreateLuisResource: pack(shouldCreateLuisResource),
shouldCreateQnAResource: pack(shouldCreateQnAResource),
useAppInsights: pack(useAppInsights),
useCosmosDb: pack(useCosmosDb),
useStorage: pack(useStorage),
};
};
/**
* Validate the deployment using the Azure API
*/
const validateDeployment = async (
client,
resourceGroupName,
deployName,
templateParam
) => {
logger({
status: BotProjectDeployLoggerType.PROVISION_INFO,
message: "> Validating Azure deployment ...",
});
const templateFile = await readFile(templatePath, { encoding: "utf-8" });
const deployParam = {
properties: {
template: JSON.parse(templateFile),
parameters: templateParam,
mode: "Incremental",
},
};
return await client.deployments.validate(
resourceGroupName,
deployName,
deployParam
);
};
/**
* Using an ARM template, provision a bunch of resources
*/
const createDeployment = async (
client,
resourceGroupName,
deployName,
templateParam
) => {
const templateFile = await readFile(templatePath, { encoding: "utf-8" });
const deployParam = {
properties: {
template: JSON.parse(templateFile),
parameters: templateParam,
mode: "Incremental",
},
};
return await client.deployments.createOrUpdate(
resourceGroupName,
deployName,
deployParam
);
};
/**
* Format the results into the expected shape
*/
const updateDeploymentJsonFile = async (
client,
resourceGroupName,
deployName,
appId,
appPwd
) => {
const outputs = await client.deployments.get(resourceGroupName, deployName);
if (outputs && outputs.properties && outputs.properties.outputs) {
const outputResult = outputs.properties.outputs;
const applicationResult = {
MicrosoftAppId: appId,
MicrosoftAppPassword: appPwd,
};
const outputObj = unpackObject(outputResult);
if (!createAppInsights) {
delete outputObj.applicationInsights;
}
if (!createCosmosDb) {
delete outputObj.cosmosDb;
}
if (!createLuisAuthoringResource && !createLuisResource) {
delete outputObj.luis;
}
if (!createStorage) {
delete outputObj.blobStorage;
}
const result = {};
Object.assign(result, outputObj, applicationResult);
return result;
} else {
return null;
}
};
const provisionFailed = (msg) => {
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: chalk.bold("** Provision failed **"),
});
};
const getErrorMesssage = (err) => {
if (err.body) {
if (err.body.error) {
if (err.body.error.details) {
const details = err.body.error.details;
let errMsg = "";
for (let detail of details) {
errMsg += detail.message;
}
return errMsg;
} else {
return err.body.error.message;
}
} else {
return JSON.stringify(err.body, null, 2);
}
} else {
return JSON.stringify(err, null, 2);
}
};
/**
* Provision a set of Azure resources for use with a bot
*/
const create = async (
creds,
subId,
name,
location,
environment,
appId,
appPassword,
createLuisResource = true,
createLuisAuthoringResource = true,
createQnAResource = true,
createCosmosDb = true,
createStorage = true,
createAppInsights = true
) => {
// If tenantId is empty string, get tenanId from API
if (!tenantId) {
const token = await creds.getToken();
const accessToken = token.accessToken;
// the returned access token will almost surely have a tenantId.
// use this as the default if one isn't specified.
if (token.tenantId) {
tenantId = token.tenantId;
logger({
status: BotProjectDeployLoggerType.PROVISION_INFO,
message: `> Using Tenant ID: ${tenantId}`,
});
} else {
tenantId = await getTenantId(accessToken);
}
}
const graphCreds = new msRestNodeAuth.DeviceTokenCredentials(
creds.clientId,
tenantId,
creds.username,
"graph",
creds.environment,
creds.tokenCache
);
const graphClient = new GraphRbacManagementClient(graphCreds, tenantId, {
baseUri: "https://graph.windows.net",
});
// If the appId is not specified, create one
if (!appId) {
logger({
status: BotProjectDeployLoggerType.PROVISION_INFO,
message: "> Creating App Registration ...",
});
// create the app registration
const appCreated = await createApp(
graphClient,
`${name}-${environment}`,
appPassword
);
if (appCreated === false) {
return provisionFailed();
}
// use the newly created app
appId = appCreated.appId;
}
logger({
status: BotProjectDeployLoggerType.PROVISION_INFO,
message: `> Create App Id Success! ID: ${appId}`,
});
const resourceGroupName = `${name}-${environment}`;
const deployName = `${name}-${environment}-deploy`;
// timestamp will be used as deployment name
const timeStamp = new Date().getTime().toString();
const client = new ResourceManagementClient(creds, subId);
// Create a resource group to contain the new resources
try {
const rpres = await createResourceGroup(
client,
location,
resourceGroupName
);
} catch (err) {
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: getErrorMesssage(err),
});
return provisionFailed();
}
// Caste the parameters into the right format
const deploymentTemplateParam = getDeploymentTemplateParam(
appId,
appPassword,
location,
`${name}-${environment}`,
createLuisAuthoringResource,
createQnAResource,
createLuisResource,
createAppInsights,
createCosmosDb,
createStorage
);
// Validate the deployment using the Azure API
const validation = await validateDeployment(
client,
resourceGroupName,
deployName,
deploymentTemplateParam
);
// Handle validation errors
if (validation.error) {
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: `! Error: ${validation.error.message}`,
});
if (validation.error.details) {
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR_DETAILS,
message: JSON.stringify(validation.error.details, null, 2),
});
}
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: `+ To delete this resource group, run 'az group delete -g ${resourceGroupName} --no-wait'`,
});
return provisionFailed();
}
// Create the entire stack of resources inside the new resource group
// this is controlled by an ARM template identified in templatePath
logger({
status: BotProjectDeployLoggerType.PROVISION_INFO,
message: `> Deploying Azure services (this could take a while)...`,
});
const spinner = ora().start();
try {
const deployment = await createDeployment(
client,
resourceGroupName,
deployName,
deploymentTemplateParam
);
// Handle errors
if (deployment._response.status != 200) {
spinner.fail();
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: `! Template is not valid with provided parameters. Review the log for more information.`,
});
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: `! Error: ${validation.error}`,
});
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: `+ To delete this resource group, run 'az group delete -g ${resourceGroupName} --no-wait'`,
});
return provisionFailed();
}
} catch (err) {
spinner.fail();
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: getErrorMesssage(err),
});
return provisionFailed();
}
// If application insights created, update the application insights settings in azure bot service
if (createAppInsights) {
logger({
status: BotProjectDeployLoggerType.PROVISION_INFO,
message: `> Linking Application Insights settings to Bot Service ...`,
});
const appinsightsClient = new ApplicationInsightsManagementClient(
creds,
subId
);
const appComponents = await appinsightsClient.components.get(
resourceGroupName,
resourceGroupName
);
const appinsightsId = appComponents.appId;
const appinsightsInstrumentationKey = appComponents.instrumentationKey;
const apiKeyOptions = {
name: `${resourceGroupName}-provision-${timeStamp}`,
linkedReadProperties: [
`/subscriptions/${subId}/resourceGroups/${resourceGroupName}/providers/microsoft.insights/components/${resourceGroupName}/api`,
`/subscriptions/${subId}/resourceGroups/${resourceGroupName}/providers/microsoft.insights/components/${resourceGroupName}/agentconfig`,
],
linkedWriteProperties: [
`/subscriptions/${subId}/resourceGroups/${resourceGroupName}/providers/microsoft.insights/components/${resourceGroupName}/annotations`,
],
};
const appinsightsApiKeyResponse = await appinsightsClient.aPIKeys.create(
resourceGroupName,
resourceGroupName,
apiKeyOptions
);
const appinsightsApiKey = appinsightsApiKeyResponse.apiKey;
logger({
status: BotProjectDeployLoggerType.PROVISION_INFO,
message: `> AppInsights AppId: ${appinsightsId} ...`,
});
logger({
status: BotProjectDeployLoggerType.PROVISION_INFO,
message: `> AppInsights InstrumentationKey: ${appinsightsInstrumentationKey} ...`,
});
logger({
status: BotProjectDeployLoggerType.PROVISION_INFO,
message: `> AppInsights ApiKey: ${appinsightsApiKey} ...`,
});
if (appinsightsId && appinsightsInstrumentationKey && appinsightsApiKey) {
const botServiceClient = new AzureBotService(creds, subId);
const botCreated = await botServiceClient.bots.get(
resourceGroupName,
`${name}-${environment}`
);
if (botCreated.properties) {
botCreated.properties.developerAppInsightKey = appinsightsInstrumentationKey;
botCreated.properties.developerAppInsightsApiKey = appinsightsApiKey;
botCreated.properties.developerAppInsightsApplicationId = appinsightsId;
const botUpdateResult = await botServiceClient.bots.update(
resourceGroupName,
`${name}-${environment}`,
botCreated
);
if (botUpdateResult._response.status != 200) {
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: `! Something went wrong while trying to link Application Insights settings to Bot Service Result: ${JSON.stringify(
botUpdateResult
)}`,
});
throw new Error(`Linking Application Insights Failed.`);
}
logger({
status: BotProjectDeployLoggerType.PROVISION_INFO,
message: `> Linking Application Insights settings to Bot Service Success!`,
});
} else {
logger({
status: BotProjectDeployLoggerType.PROVISION_WARNING,
message: `! The Bot doesn't have a keys properties to update.`,
});
}
}
}
spinner.succeed("Success!");
// Validate that everything was successfully created.
// Then, update the settings file with information about the new resources
const updateResult = await updateDeploymentJsonFile(
client,
resourceGroupName,
deployName,
appId,
appPassword
);
// Handle errors
if (!updateResult) {
const operations = await client.deploymentOperations.list(
resourceGroupName,
deployName
);
if (operations) {
const failedOperations = operations.filter(
(value) =>
value &&
value.properties &&
value.properties.statusMessage.error !== null
);
if (failedOperations) {
failedOperations.forEach((operation) => {
switch (
operation &&
operation.properties &&
operation.properties.statusMessage.error.code &&
operation.properties.targetResource
) {
case "MissingRegistrationForLocation":
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: `! Deployment failed for resource of type ${operation.properties.targetResource.resourceType}. This resource is not avaliable in the location provided.`,
});
break;
default:
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: `! Deployment failed for resource of type ${operation.properties.targetResource.resourceType}.`,
});
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: `! Code: ${operation.properties.statusMessage.error.code}.`,
});
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: `! Message: ${operation.properties.statusMessage.error.message}.`,
});
break;
}
});
}
} else {
logger({
status: BotProjectDeployLoggerType.PROVISION_ERROR,
message: `! Deployment failed. Please refer to the log file for more information.`,
});
}
}
return updateResult;
};
console.log(chalk.bold("Login to Azure:"));
msRestNodeAuth
.interactiveLogin({ domain: tenantId })
.then(async (creds) => {
const createResult = await create(
creds,
subId,
name,
location,
environment,
appId,
appPassword,
createLuisResource,
createLuisAuthoringResource,
createQnAResource,
createCosmosDb,
createStorage,
createAppInsights
);
if (createResult) {
console.log("");
console.log(
chalk.bold(
`Your Azure hosting environment has been created! Copy paste the following configuration into a new profile in Composer's Publishing tab.`
)
);
console.log("");
const token = await creds.getToken();
const profile = {
accessToken: token.accessToken,
name: `${name}-${environment}`,
environment: environment,
hostname: `${name}-${environment}`,
luisResource: `${name}-${environment}-luis`,
settings: createResult,
};
console.log(chalk.white(JSON.stringify(profile, null, 2)));
console.log("");
}
})
.catch((err) => {
console.error(err);
});
Hope it works for you as well!

Serverless warning: No principalId in response when there is

Trying to integrate serverless-local-authorizers-plugin to a system that uses AWS Lambda Authorizer. When I print the response it does contain a principalId and I return it in an object exactly like the online lambda response does. Any ideas why I am getting the error
Serverless: Warning: No principalId in response?
How it was returned:
{
"principalId":"user",
"policyDocument":{
"Version":"2012-10-17",
"Statement":[{
"Action":"execute-api:Invoke",
"Effect":"Deny",
"Resource":"arn:aws:execute-api:eu-central-1:my-AWS-ID:*"}
]},
"context":{
"platformRoles":"Guest",
"userId":"unknown"
}
}
local auth proxy function
const AWS = require('aws-sdk');
const mylocalAuthProxyFn = async (event, context) => {
const lambda = new AWS.Lambda();
const req = {
FunctionName: 'my-lambda-function-name',
InvocationType: 'RequestResponse',
Payload: JSON.stringify(event)
};
const results = await lambda.invoke(req).promise();
if (results.StatusCode === 200) {
return results.Payload;
}
throw new Error('Unauthorized');
};
module.exports = { mylocalAuthProxyFn };

Here is what I have figured out the works. After speaking to the library owenrs, the response has to be an explicit object in my case for some reason. They claim you can send the references variable of the promise but it didn't work for me. But the below does:
const AWS = require('aws-sdk');
const mylocalAuthProxyFn = async (event, context) => {
const lambda = new AWS.Lambda();
const req = {
FunctionName: 'aidonic-endpoints-dev-createAuthorization',
InvocationType: 'RequestResponse',
Payload: JSON.stringify(event)
};
const result = await lambda.invoke(req).promise();
if (result.StatusCode === 200) {
const pl = JSON.parse(result.Payload);
return {
principalId: pl.principalId,
policyDocument: {
Version: '2012-10-17',
Statement: [
{
Action: 'execute-api:Invoke',
Effect: 'Allow',
Resource: '*'
}
]
},
context: {
platformRoles: 'Verified Organization Representative,Registered User',
userId: '23e8320fcechi042389h02ijwqwd'
}
};
}
throw new Error('Unauthorized');
};
module.exports = { mylocalAuthProxyFn };

Develop Reference

ruby bash windows laravel spring algorithm oracle macos go visual-studio

Signature verification failed - solana

Related

Redis - The client is closed

Unable to upload file graphql urql

Post Error with Apollo Client While Creating a New User

The bot name is already registered to another bot application

Serverless warning: No principalId in response when there is

Categories

Resources