mirror of
https://github.com/Azure/cosmos-explorer.git
synced 2025-03-13 05:15:30 +00:00
633 lines
23 KiB
TypeScript
633 lines
23 KiB
TypeScript
import * as ko from "knockout";
|
|
import Q from "q";
|
|
|
|
import { displayTokenRenewalPromptForStatus, getAuthorizationHeader } from "../../Utils/AuthorizationUtils";
|
|
import { AuthType } from "../../AuthType";
|
|
import { ConsoleDataType } from "../../Explorer/Menus/NotificationConsole/NotificationConsoleComponent";
|
|
import { FeedOptions } from "@azure/cosmos";
|
|
import * as Constants from "../../Common/Constants";
|
|
import * as Entities from "./Entities";
|
|
import * as HeadersUtility from "../../Common/HeadersUtility";
|
|
import * as NotificationConsoleUtils from "../../Utils/NotificationConsoleUtils";
|
|
import * as TableConstants from "./Constants";
|
|
import * as TableEntityProcessor from "./TableEntityProcessor";
|
|
import * as ViewModels from "../../Contracts/ViewModels";
|
|
import Explorer from "../Explorer";
|
|
import { configContext } from "../../ConfigContext";
|
|
import { handleError } from "../../Common/ErrorHandlingUtils";
|
|
import { createDocument } from "../../Common/dataAccess/createDocument";
|
|
import { deleteDocument } from "../../Common/dataAccess/deleteDocument";
|
|
import { queryDocuments } from "../../Common/dataAccess/queryDocuments";
|
|
import { updateDocument } from "../../Common/dataAccess/updateDocument";
|
|
|
|
export interface CassandraTableKeys {
|
|
partitionKeys: CassandraTableKey[];
|
|
clusteringKeys: CassandraTableKey[];
|
|
}
|
|
|
|
export interface CassandraTableKey {
|
|
property: string;
|
|
type: string;
|
|
}
|
|
|
|
export abstract class TableDataClient {
|
|
constructor() {}
|
|
|
|
public abstract createDocument(
|
|
collection: ViewModels.Collection,
|
|
entity: Entities.ITableEntity
|
|
): Q.Promise<Entities.ITableEntity>;
|
|
|
|
public abstract updateDocument(
|
|
collection: ViewModels.Collection,
|
|
originalDocument: any,
|
|
newEntity: Entities.ITableEntity
|
|
): Promise<Entities.ITableEntity>;
|
|
|
|
public abstract queryDocuments(
|
|
collection: ViewModels.Collection,
|
|
query: string,
|
|
shouldNotify?: boolean,
|
|
paginationToken?: string
|
|
): Promise<Entities.IListTableEntitiesResult>;
|
|
|
|
public abstract deleteDocuments(
|
|
collection: ViewModels.Collection,
|
|
entitiesToDelete: Entities.ITableEntity[]
|
|
): Promise<any>;
|
|
}
|
|
|
|
export class TablesAPIDataClient extends TableDataClient {
|
|
public createDocument(
|
|
collection: ViewModels.Collection,
|
|
entity: Entities.ITableEntity
|
|
): Q.Promise<Entities.ITableEntity> {
|
|
const deferred = Q.defer<Entities.ITableEntity>();
|
|
createDocument(
|
|
collection,
|
|
TableEntityProcessor.convertEntityToNewDocument(<Entities.ITableEntityForTablesAPI>entity)
|
|
).then(
|
|
(newDocument: any) => {
|
|
const newEntity = TableEntityProcessor.convertDocumentsToEntities([newDocument])[0];
|
|
deferred.resolve(newEntity);
|
|
},
|
|
reason => {
|
|
deferred.reject(reason);
|
|
}
|
|
);
|
|
return deferred.promise;
|
|
}
|
|
|
|
public async updateDocument(
|
|
collection: ViewModels.Collection,
|
|
originalDocument: any,
|
|
entity: Entities.ITableEntity
|
|
): Promise<Entities.ITableEntity> {
|
|
try {
|
|
const newDocument = await updateDocument(
|
|
collection,
|
|
originalDocument,
|
|
TableEntityProcessor.convertEntityToNewDocument(<Entities.ITableEntityForTablesAPI>entity)
|
|
);
|
|
return TableEntityProcessor.convertDocumentsToEntities([newDocument])[0];
|
|
} catch (error) {
|
|
handleError(error, "TablesAPIDataClient/updateDocument");
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
public async queryDocuments(
|
|
collection: ViewModels.Collection,
|
|
query: string
|
|
): Promise<Entities.IListTableEntitiesResult> {
|
|
try {
|
|
const options = {
|
|
enableCrossPartitionQuery: HeadersUtility.shouldEnableCrossPartitionKey()
|
|
} as FeedOptions;
|
|
const iterator = queryDocuments(collection.databaseId, collection.id(), query, options);
|
|
const response = await iterator.fetchNext();
|
|
const documents = response?.resources;
|
|
const entities = TableEntityProcessor.convertDocumentsToEntities(documents);
|
|
|
|
return {
|
|
Results: entities,
|
|
ContinuationToken: iterator.hasMoreResults(),
|
|
iterator: iterator
|
|
};
|
|
} catch (error) {
|
|
handleError(error, "TablesAPIDataClient/queryDocuments", "Query documents failed");
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
public async deleteDocuments(
|
|
collection: ViewModels.Collection,
|
|
entitiesToDelete: Entities.ITableEntity[]
|
|
): Promise<any> {
|
|
const documentsToDelete: any[] = TableEntityProcessor.convertEntitiesToDocuments(
|
|
<Entities.ITableEntityForTablesAPI[]>entitiesToDelete,
|
|
collection
|
|
);
|
|
|
|
await Promise.all(
|
|
documentsToDelete?.map(async document => {
|
|
document.id = ko.observable<string>(document.id);
|
|
await deleteDocument(collection, document);
|
|
})
|
|
);
|
|
}
|
|
}
|
|
|
|
export class CassandraAPIDataClient extends TableDataClient {
|
|
public createDocument(
|
|
collection: ViewModels.Collection,
|
|
entity: Entities.ITableEntity
|
|
): Q.Promise<Entities.ITableEntity> {
|
|
const notificationId = NotificationConsoleUtils.logConsoleMessage(
|
|
ConsoleDataType.InProgress,
|
|
`Adding new row to table ${collection.id()}`
|
|
);
|
|
let properties = "(";
|
|
let values = "(";
|
|
for (let property in entity) {
|
|
if (entity[property]._ === null) {
|
|
continue;
|
|
}
|
|
properties = properties.concat(`${property}, `);
|
|
const propertyType = entity[property].$;
|
|
if (this.isStringType(propertyType)) {
|
|
values = values.concat(`'${entity[property]._}', `);
|
|
} else {
|
|
values = values.concat(`${entity[property]._}, `);
|
|
}
|
|
}
|
|
properties = properties.slice(0, properties.length - 2) + ")";
|
|
values = values.slice(0, values.length - 2) + ")";
|
|
const query = `INSERT INTO ${collection.databaseId}.${collection.id()} ${properties} VALUES ${values}`;
|
|
const deferred = Q.defer<Entities.ITableEntity>();
|
|
this.queryDocuments(collection, query)
|
|
.then(
|
|
(data: any) => {
|
|
entity[TableConstants.EntityKeyNames.RowKey] = entity[this.getCassandraPartitionKeyProperty(collection)];
|
|
entity[TableConstants.EntityKeyNames.RowKey]._ = entity[TableConstants.EntityKeyNames.RowKey]._.toString();
|
|
NotificationConsoleUtils.logConsoleInfo(`Successfully added new row to table ${collection.id()}`);
|
|
deferred.resolve(entity);
|
|
},
|
|
error => {
|
|
handleError(error, "AddRowCassandra", `Error while adding new row to table ${collection.id()}`);
|
|
deferred.reject(error);
|
|
}
|
|
)
|
|
.finally(() => {
|
|
NotificationConsoleUtils.clearInProgressMessageWithId(notificationId);
|
|
});
|
|
return deferred.promise;
|
|
}
|
|
|
|
public async updateDocument(
|
|
collection: ViewModels.Collection,
|
|
originalDocument: any,
|
|
newEntity: Entities.ITableEntity
|
|
): Promise<Entities.ITableEntity> {
|
|
const clearMessage = NotificationConsoleUtils.logConsoleProgress(`Updating row ${originalDocument.RowKey._}`);
|
|
|
|
try {
|
|
let whereSegment = " WHERE";
|
|
let keys: CassandraTableKey[] = collection.cassandraKeys.partitionKeys.concat(
|
|
collection.cassandraKeys.clusteringKeys
|
|
);
|
|
for (let keyIndex in keys) {
|
|
const key = keys[keyIndex].property;
|
|
const keyType = keys[keyIndex].type;
|
|
whereSegment += this.isStringType(keyType)
|
|
? ` ${key} = '${newEntity[key]._}' AND`
|
|
: ` ${key} = ${newEntity[key]._} AND`;
|
|
}
|
|
whereSegment = whereSegment.slice(0, whereSegment.length - 4);
|
|
|
|
let updateQuery = `UPDATE ${collection.databaseId}.${collection.id()}`;
|
|
let isPropertyUpdated = false;
|
|
for (let property in newEntity) {
|
|
if (
|
|
!originalDocument[property] ||
|
|
newEntity[property]._.toString() !== originalDocument[property]._.toString()
|
|
) {
|
|
updateQuery += this.isStringType(newEntity[property].$)
|
|
? ` SET ${property} = '${newEntity[property]._}',`
|
|
: ` SET ${property} = ${newEntity[property]._},`;
|
|
isPropertyUpdated = true;
|
|
}
|
|
}
|
|
|
|
if (isPropertyUpdated) {
|
|
updateQuery = updateQuery.slice(0, updateQuery.length - 1);
|
|
updateQuery += whereSegment;
|
|
await this.queryDocuments(collection, updateQuery);
|
|
}
|
|
|
|
let deleteQuery = `DELETE `;
|
|
let isPropertyDeleted = false;
|
|
for (let property in originalDocument) {
|
|
if (property !== TableConstants.EntityKeyNames.RowKey && !newEntity[property] && !!originalDocument[property]) {
|
|
deleteQuery += ` ${property},`;
|
|
isPropertyDeleted = true;
|
|
}
|
|
}
|
|
|
|
if (isPropertyDeleted) {
|
|
deleteQuery = deleteQuery.slice(0, deleteQuery.length - 1);
|
|
deleteQuery += ` FROM ${collection.databaseId}.${collection.id()}${whereSegment}`;
|
|
await this.queryDocuments(collection, deleteQuery);
|
|
}
|
|
|
|
newEntity[TableConstants.EntityKeyNames.RowKey] = originalDocument[TableConstants.EntityKeyNames.RowKey];
|
|
NotificationConsoleUtils.logConsoleInfo(`Successfully updated row ${newEntity.RowKey._}`);
|
|
return newEntity;
|
|
} catch (error) {
|
|
handleError(error, "UpdateRowCassandra", "Failed to update row ${newEntity.RowKey._}");
|
|
throw error;
|
|
} finally {
|
|
clearMessage();
|
|
}
|
|
}
|
|
|
|
public async queryDocuments(
|
|
collection: ViewModels.Collection,
|
|
query: string,
|
|
shouldNotify?: boolean,
|
|
paginationToken?: string
|
|
): Promise<Entities.IListTableEntitiesResult> {
|
|
const clearMessage =
|
|
shouldNotify && NotificationConsoleUtils.logConsoleProgress(`Querying rows for table ${collection.id()}`);
|
|
try {
|
|
const authType = window.authType;
|
|
const apiEndpoint: string =
|
|
authType === AuthType.EncryptedToken
|
|
? Constants.CassandraBackend.guestQueryApi
|
|
: Constants.CassandraBackend.queryApi;
|
|
const data: any = await $.ajax(`${configContext.BACKEND_ENDPOINT}/${apiEndpoint}`, {
|
|
type: "POST",
|
|
data: {
|
|
accountName:
|
|
collection && collection.container.databaseAccount && collection.container.databaseAccount().name,
|
|
cassandraEndpoint: this.trimCassandraEndpoint(
|
|
collection.container.databaseAccount().properties.cassandraEndpoint
|
|
),
|
|
resourceId: collection.container.databaseAccount().id,
|
|
keyspaceId: collection.databaseId,
|
|
tableId: collection.id(),
|
|
query,
|
|
paginationToken
|
|
},
|
|
beforeSend: this.setAuthorizationHeader,
|
|
error: this.handleAjaxError,
|
|
cache: false
|
|
});
|
|
shouldNotify &&
|
|
NotificationConsoleUtils.logConsoleInfo(
|
|
`Successfully fetched ${data.result.length} rows for table ${collection.id()}`
|
|
);
|
|
return {
|
|
Results: data.result,
|
|
ContinuationToken: data.paginationToken
|
|
};
|
|
} catch (error) {
|
|
shouldNotify &&
|
|
handleError(error, "QueryDocumentsCassandra", `Failed to query rows for table ${collection.id()}`);
|
|
throw error;
|
|
} finally {
|
|
clearMessage?.();
|
|
}
|
|
}
|
|
|
|
public async deleteDocuments(
|
|
collection: ViewModels.Collection,
|
|
entitiesToDelete: Entities.ITableEntity[]
|
|
): Promise<any> {
|
|
const query = `DELETE FROM ${collection.databaseId}.${collection.id()} WHERE `;
|
|
const partitionKeyProperty = this.getCassandraPartitionKeyProperty(collection);
|
|
|
|
await Promise.all(
|
|
entitiesToDelete.map(async (currEntityToDelete: Entities.ITableEntity) => {
|
|
const clearMessage = NotificationConsoleUtils.logConsoleProgress(`Deleting row ${currEntityToDelete.RowKey._}`);
|
|
const partitionKeyValue = currEntityToDelete[partitionKeyProperty];
|
|
const currQuery =
|
|
query +
|
|
(this.isStringType(partitionKeyValue.$)
|
|
? `${partitionKeyProperty} = '${partitionKeyValue._}'`
|
|
: `${partitionKeyProperty} = ${partitionKeyValue._}`);
|
|
|
|
try {
|
|
await this.queryDocuments(collection, currQuery);
|
|
NotificationConsoleUtils.logConsoleInfo(`Successfully deleted row ${currEntityToDelete.RowKey._}`);
|
|
} catch (error) {
|
|
handleError(error, "DeleteRowCassandra", `Error while deleting row ${currEntityToDelete.RowKey._}`);
|
|
throw error;
|
|
} finally {
|
|
clearMessage();
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
public createKeyspace(
|
|
cassandraEndpoint: string,
|
|
resourceId: string,
|
|
explorer: Explorer,
|
|
createKeyspaceQuery: string
|
|
): Q.Promise<any> {
|
|
if (!createKeyspaceQuery) {
|
|
return Q.reject("No query specified");
|
|
}
|
|
|
|
const deferred: Q.Deferred<any> = Q.defer();
|
|
const notificationId = NotificationConsoleUtils.logConsoleMessage(
|
|
ConsoleDataType.InProgress,
|
|
`Creating a new keyspace with query ${createKeyspaceQuery}`
|
|
);
|
|
this.createOrDeleteQuery(cassandraEndpoint, resourceId, createKeyspaceQuery, explorer)
|
|
.then(
|
|
(data: any) => {
|
|
NotificationConsoleUtils.logConsoleMessage(
|
|
ConsoleDataType.Info,
|
|
`Successfully created a keyspace with query ${createKeyspaceQuery}`
|
|
);
|
|
deferred.resolve();
|
|
},
|
|
error => {
|
|
handleError(
|
|
error,
|
|
"CreateKeyspaceCassandra",
|
|
`Error while creating a keyspace with query ${createKeyspaceQuery}`
|
|
);
|
|
deferred.reject(error);
|
|
}
|
|
)
|
|
.finally(() => {
|
|
NotificationConsoleUtils.clearInProgressMessageWithId(notificationId);
|
|
});
|
|
|
|
return deferred.promise.timeout(Constants.ClientDefaults.requestTimeoutMs);
|
|
}
|
|
|
|
public createTableAndKeyspace(
|
|
cassandraEndpoint: string,
|
|
resourceId: string,
|
|
explorer: Explorer,
|
|
createTableQuery: string,
|
|
createKeyspaceQuery?: string
|
|
): Q.Promise<any> {
|
|
let createKeyspacePromise: Q.Promise<any>;
|
|
if (createKeyspaceQuery) {
|
|
createKeyspacePromise = this.createKeyspace(cassandraEndpoint, resourceId, explorer, createKeyspaceQuery);
|
|
} else {
|
|
createKeyspacePromise = Q.resolve(null);
|
|
}
|
|
|
|
const deferred = Q.defer();
|
|
createKeyspacePromise.then(
|
|
() => {
|
|
const notificationId = NotificationConsoleUtils.logConsoleMessage(
|
|
ConsoleDataType.InProgress,
|
|
`Creating a new table with query ${createTableQuery}`
|
|
);
|
|
this.createOrDeleteQuery(cassandraEndpoint, resourceId, createTableQuery, explorer)
|
|
.then(
|
|
(data: any) => {
|
|
NotificationConsoleUtils.logConsoleMessage(
|
|
ConsoleDataType.Info,
|
|
`Successfully created a table with query ${createTableQuery}`
|
|
);
|
|
deferred.resolve();
|
|
},
|
|
error => {
|
|
handleError(error, "CreateTableCassandra", `Error while creating a table with query ${createTableQuery}`);
|
|
deferred.reject(error);
|
|
}
|
|
)
|
|
.finally(() => {
|
|
NotificationConsoleUtils.clearInProgressMessageWithId(notificationId);
|
|
});
|
|
},
|
|
reason => {
|
|
deferred.reject(reason);
|
|
}
|
|
);
|
|
return deferred.promise;
|
|
}
|
|
|
|
public deleteTableOrKeyspace(
|
|
cassandraEndpoint: string,
|
|
resourceId: string,
|
|
deleteQuery: string,
|
|
explorer: Explorer
|
|
): Q.Promise<any> {
|
|
const deferred = Q.defer<any>();
|
|
const notificationId = NotificationConsoleUtils.logConsoleMessage(
|
|
ConsoleDataType.InProgress,
|
|
`Deleting resource with query ${deleteQuery}`
|
|
);
|
|
this.createOrDeleteQuery(cassandraEndpoint, resourceId, deleteQuery, explorer)
|
|
.then(
|
|
() => {
|
|
NotificationConsoleUtils.logConsoleMessage(
|
|
ConsoleDataType.Info,
|
|
`Successfully deleted resource with query ${deleteQuery}`
|
|
);
|
|
deferred.resolve();
|
|
},
|
|
error => {
|
|
handleError(
|
|
error,
|
|
"DeleteKeyspaceOrTableCassandra",
|
|
`Error while deleting resource with query ${deleteQuery}`
|
|
);
|
|
deferred.reject(error);
|
|
}
|
|
)
|
|
.finally(() => {
|
|
NotificationConsoleUtils.clearInProgressMessageWithId(notificationId);
|
|
});
|
|
return deferred.promise;
|
|
}
|
|
|
|
public getTableKeys(collection: ViewModels.Collection): Q.Promise<CassandraTableKeys> {
|
|
if (!!collection.cassandraKeys) {
|
|
return Q.resolve(collection.cassandraKeys);
|
|
}
|
|
const notificationId = NotificationConsoleUtils.logConsoleMessage(
|
|
ConsoleDataType.InProgress,
|
|
`Fetching keys for table ${collection.id()}`
|
|
);
|
|
const authType = window.authType;
|
|
const apiEndpoint: string =
|
|
authType === AuthType.EncryptedToken
|
|
? Constants.CassandraBackend.guestKeysApi
|
|
: Constants.CassandraBackend.keysApi;
|
|
let endpoint = `${configContext.BACKEND_ENDPOINT}/${apiEndpoint}`;
|
|
const deferred = Q.defer<CassandraTableKeys>();
|
|
$.ajax(endpoint, {
|
|
type: "POST",
|
|
data: {
|
|
accountName: collection && collection.container.databaseAccount && collection.container.databaseAccount().name,
|
|
cassandraEndpoint: this.trimCassandraEndpoint(
|
|
collection.container.databaseAccount().properties.cassandraEndpoint
|
|
),
|
|
resourceId: collection.container.databaseAccount().id,
|
|
keyspaceId: collection.databaseId,
|
|
tableId: collection.id()
|
|
},
|
|
beforeSend: this.setAuthorizationHeader,
|
|
error: this.handleAjaxError,
|
|
cache: false
|
|
})
|
|
.then(
|
|
(data: CassandraTableKeys) => {
|
|
collection.cassandraKeys = data;
|
|
NotificationConsoleUtils.logConsoleMessage(
|
|
ConsoleDataType.Info,
|
|
`Successfully fetched keys for table ${collection.id()}`
|
|
);
|
|
deferred.resolve(data);
|
|
},
|
|
(error: any) => {
|
|
handleError(error, "FetchKeysCassandra", `Error fetching keys for table ${collection.id()}`);
|
|
deferred.reject(error);
|
|
}
|
|
)
|
|
.done(() => {
|
|
NotificationConsoleUtils.clearInProgressMessageWithId(notificationId);
|
|
});
|
|
return deferred.promise;
|
|
}
|
|
|
|
public getTableSchema(collection: ViewModels.Collection): Q.Promise<CassandraTableKey[]> {
|
|
if (!!collection.cassandraSchema) {
|
|
return Q.resolve(collection.cassandraSchema);
|
|
}
|
|
const notificationId = NotificationConsoleUtils.logConsoleMessage(
|
|
ConsoleDataType.InProgress,
|
|
`Fetching schema for table ${collection.id()}`
|
|
);
|
|
const authType = window.authType;
|
|
const apiEndpoint: string =
|
|
authType === AuthType.EncryptedToken
|
|
? Constants.CassandraBackend.guestSchemaApi
|
|
: Constants.CassandraBackend.schemaApi;
|
|
let endpoint = `${configContext.BACKEND_ENDPOINT}/${apiEndpoint}`;
|
|
const deferred = Q.defer<CassandraTableKey[]>();
|
|
$.ajax(endpoint, {
|
|
type: "POST",
|
|
data: {
|
|
accountName: collection && collection.container.databaseAccount && collection.container.databaseAccount().name,
|
|
cassandraEndpoint: this.trimCassandraEndpoint(
|
|
collection.container.databaseAccount().properties.cassandraEndpoint
|
|
),
|
|
resourceId: collection.container.databaseAccount().id,
|
|
keyspaceId: collection.databaseId,
|
|
tableId: collection.id()
|
|
},
|
|
beforeSend: this.setAuthorizationHeader,
|
|
error: this.handleAjaxError,
|
|
cache: false
|
|
})
|
|
.then(
|
|
(data: any) => {
|
|
collection.cassandraSchema = data.columns;
|
|
NotificationConsoleUtils.logConsoleMessage(
|
|
ConsoleDataType.Info,
|
|
`Successfully fetched schema for table ${collection.id()}`
|
|
);
|
|
deferred.resolve(data.columns);
|
|
},
|
|
(error: any) => {
|
|
handleError(error, "FetchSchemaCassandra", `Error fetching schema for table ${collection.id()}`);
|
|
deferred.reject(error);
|
|
}
|
|
)
|
|
.done(() => {
|
|
NotificationConsoleUtils.clearInProgressMessageWithId(notificationId);
|
|
});
|
|
return deferred.promise;
|
|
}
|
|
|
|
private createOrDeleteQuery(
|
|
cassandraEndpoint: string,
|
|
resourceId: string,
|
|
query: string,
|
|
explorer: Explorer
|
|
): Q.Promise<any> {
|
|
const deferred = Q.defer();
|
|
const authType = window.authType;
|
|
const apiEndpoint: string =
|
|
authType === AuthType.EncryptedToken
|
|
? Constants.CassandraBackend.guestCreateOrDeleteApi
|
|
: Constants.CassandraBackend.createOrDeleteApi;
|
|
$.ajax(`${configContext.BACKEND_ENDPOINT}/${apiEndpoint}`, {
|
|
type: "POST",
|
|
data: {
|
|
accountName: explorer.databaseAccount() && explorer.databaseAccount().name,
|
|
cassandraEndpoint: this.trimCassandraEndpoint(cassandraEndpoint),
|
|
resourceId: resourceId,
|
|
query: query
|
|
},
|
|
beforeSend: this.setAuthorizationHeader,
|
|
error: this.handleAjaxError,
|
|
cache: false
|
|
}).then(
|
|
(data: any) => {
|
|
deferred.resolve();
|
|
},
|
|
reason => {
|
|
deferred.reject(reason);
|
|
}
|
|
);
|
|
return deferred.promise;
|
|
}
|
|
|
|
private trimCassandraEndpoint(cassandraEndpoint: string): string {
|
|
if (!cassandraEndpoint) {
|
|
return cassandraEndpoint;
|
|
}
|
|
|
|
if (cassandraEndpoint.indexOf("https://") === 0) {
|
|
cassandraEndpoint = cassandraEndpoint.slice(8, cassandraEndpoint.length);
|
|
}
|
|
|
|
if (cassandraEndpoint.indexOf(":443/", cassandraEndpoint.length - 5) !== -1) {
|
|
cassandraEndpoint = cassandraEndpoint.slice(0, cassandraEndpoint.length - 5);
|
|
}
|
|
|
|
return cassandraEndpoint;
|
|
}
|
|
|
|
private setAuthorizationHeader: (xhr: XMLHttpRequest) => boolean = (xhr: XMLHttpRequest): boolean => {
|
|
const authorizationHeaderMetadata: ViewModels.AuthorizationTokenHeaderMetadata = getAuthorizationHeader();
|
|
xhr.setRequestHeader(authorizationHeaderMetadata.header, authorizationHeaderMetadata.token);
|
|
|
|
return true;
|
|
};
|
|
|
|
private isStringType(dataType: string): boolean {
|
|
// TODO figure out rest of types that are considered strings by Cassandra (if any have been missed)
|
|
return (
|
|
dataType === TableConstants.CassandraType.Text ||
|
|
dataType === TableConstants.CassandraType.Inet ||
|
|
dataType === TableConstants.CassandraType.Ascii ||
|
|
dataType === TableConstants.CassandraType.Varchar
|
|
);
|
|
}
|
|
|
|
private getCassandraPartitionKeyProperty(collection: ViewModels.Collection): string {
|
|
return collection.cassandraKeys.partitionKeys[0].property;
|
|
}
|
|
|
|
private handleAjaxError = (xhrObj: XMLHttpRequest, textStatus: string, errorThrown: string): void => {
|
|
if (!xhrObj) {
|
|
return;
|
|
}
|
|
|
|
displayTokenRenewalPromptForStatus(xhrObj.status);
|
|
};
|
|
}
|