forked from BLC/sgeUpdated
598 lines
16 KiB
JavaScript
598 lines
16 KiB
JavaScript
import ApplicationService from "../../../services/ApplicationService";
|
|
|
|
export const getDataCenters = () => {
|
|
return async (dispatch) => {
|
|
dispatch({
|
|
type: "GET_DATA_CENTERS_LOADING",
|
|
});
|
|
|
|
// Get access token
|
|
const accessToken = localStorage.getItem("accessToken");
|
|
if (!accessToken) {
|
|
dispatch({
|
|
type: "GET_DATA_CENTERS_ERROR",
|
|
payload: {
|
|
error: "No access token found. Please log in again.",
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
ApplicationService.http()
|
|
.post(
|
|
"/graphql",
|
|
{
|
|
query: `
|
|
query GetDataCenters {
|
|
dataCenters(sortBy: [{ direction: DESC, field: "number" }]) {
|
|
id
|
|
dataCenter
|
|
externalId
|
|
ayposURL
|
|
number
|
|
address
|
|
latitude
|
|
longitude
|
|
area {
|
|
id
|
|
tag
|
|
cities {
|
|
id
|
|
name
|
|
}
|
|
districts {
|
|
id
|
|
name
|
|
}
|
|
}
|
|
city {
|
|
id
|
|
name
|
|
}
|
|
emissionScope {
|
|
id
|
|
tag
|
|
description
|
|
}
|
|
sector {
|
|
id
|
|
tag
|
|
}
|
|
subSector {
|
|
id
|
|
tag
|
|
}
|
|
dataCenterEmissionSources {
|
|
id
|
|
emissionSource {
|
|
id
|
|
tag
|
|
}
|
|
consuptionUnit {
|
|
id
|
|
description
|
|
}
|
|
isDefault
|
|
percentage
|
|
}
|
|
activitySubUnit {
|
|
id
|
|
tag
|
|
}
|
|
physicalMachines {
|
|
id
|
|
name
|
|
vms {
|
|
id
|
|
vmName
|
|
state
|
|
power
|
|
calcOn
|
|
hostingPm
|
|
host
|
|
flavorName
|
|
tag
|
|
config {
|
|
id
|
|
cpu
|
|
ram
|
|
disk
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`,
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: "Bearer " + accessToken,
|
|
"Content-Type": "application/json",
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
// Debug logging
|
|
console.log("GraphQL Response:", {
|
|
status: response.status,
|
|
data: response.data,
|
|
errors: response.data?.errors,
|
|
});
|
|
|
|
// Check for GraphQL errors
|
|
if (response.data?.errors) {
|
|
throw new Error(response.data.errors[0].message);
|
|
}
|
|
|
|
// Validate response structure
|
|
if (!response.data?.data?.dataCenters) {
|
|
throw new Error("Invalid response structure: dataCenters not found");
|
|
}
|
|
|
|
const dataCenters = response.data.data.dataCenters;
|
|
|
|
// Validate dataCenters is an array
|
|
if (!Array.isArray(dataCenters)) {
|
|
throw new Error("Invalid response: dataCenters is not an array");
|
|
}
|
|
|
|
dispatch({
|
|
type: "GET_DATA_CENTERS_SUCCESS",
|
|
payload: {
|
|
dataCenters,
|
|
},
|
|
});
|
|
})
|
|
.catch((error) => {
|
|
// Enhanced error logging
|
|
console.error("Error fetching data centers:", {
|
|
message: error.message,
|
|
response: error.response?.data,
|
|
status: error.response?.status,
|
|
stack: error.stack,
|
|
});
|
|
|
|
// Check for specific error types
|
|
let errorMessage = "Failed to fetch data centers";
|
|
if (error.response?.status === 401) {
|
|
errorMessage = "Unauthorized. Please log in again.";
|
|
} else if (error.response?.status === 403) {
|
|
errorMessage = "You don't have permission to view data centers.";
|
|
} else if (error.message) {
|
|
errorMessage = error.message;
|
|
}
|
|
|
|
dispatch({
|
|
type: "GET_DATA_CENTERS_ERROR",
|
|
payload: {
|
|
error: errorMessage,
|
|
},
|
|
});
|
|
});
|
|
};
|
|
};
|
|
|
|
export const createDataCenter = (dataCenterData) => {
|
|
return async (dispatch) => {
|
|
dispatch({
|
|
type: "CREATE_DATA_CENTER_LOADING",
|
|
});
|
|
|
|
try {
|
|
const response = await ApplicationService.http().post(
|
|
"/graphql",
|
|
{
|
|
query: `
|
|
mutation CreateDataCenter($input: DataCenterCreateInput!) {
|
|
createDataCenter(input: $input) {
|
|
id
|
|
dataCenter
|
|
externalId
|
|
ayposURL
|
|
number
|
|
address
|
|
latitude
|
|
longitude
|
|
area {
|
|
id
|
|
tag
|
|
cities {
|
|
id
|
|
name
|
|
}
|
|
districts {
|
|
id
|
|
name
|
|
}
|
|
}
|
|
city {
|
|
id
|
|
name
|
|
}
|
|
emissionScope {
|
|
id
|
|
tag
|
|
description
|
|
}
|
|
sector {
|
|
id
|
|
tag
|
|
}
|
|
subSector {
|
|
id
|
|
tag
|
|
}
|
|
dataCenterEmissionSources {
|
|
id
|
|
emissionSource {
|
|
id
|
|
tag
|
|
}
|
|
consuptionUnit {
|
|
id
|
|
description
|
|
}
|
|
isDefault
|
|
percentage
|
|
}
|
|
activitySubUnit {
|
|
id
|
|
tag
|
|
}
|
|
}
|
|
}
|
|
`,
|
|
variables: {
|
|
input: {
|
|
dataCenter: dataCenterData.name,
|
|
externalId: parseInt(dataCenterData.externalId),
|
|
ayposURL: dataCenterData.ayposURL || "",
|
|
number: parseInt(dataCenterData.number) || 1,
|
|
areaId: dataCenterData.areaId || null,
|
|
cityId: dataCenterData.cityId || null,
|
|
address: dataCenterData.address || "",
|
|
latitude: dataCenterData.latitude
|
|
? parseFloat(dataCenterData.latitude)
|
|
: null,
|
|
longitude: dataCenterData.longitude
|
|
? parseFloat(dataCenterData.longitude)
|
|
: null,
|
|
emissionScopeId: dataCenterData.emissionScopeId || null,
|
|
sectorId: dataCenterData.sectorId || null,
|
|
subSectorId: dataCenterData.subSectorId || null,
|
|
dataCenterEmissionSources:
|
|
dataCenterData.dataCenterEmissionSources || [],
|
|
activitySubUnitId: dataCenterData.activitySubUnitId || null,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: "Bearer " + localStorage.getItem("accessToken"),
|
|
},
|
|
}
|
|
);
|
|
|
|
// Debug logging
|
|
console.log("Create Response:", {
|
|
status: response.status,
|
|
data: response.data,
|
|
errors: response.data?.errors,
|
|
});
|
|
|
|
if (response.data?.errors) {
|
|
throw new Error(response.data.errors[0].message);
|
|
}
|
|
|
|
if (!response.data?.data?.createDataCenter) {
|
|
throw new Error("Invalid response: createDataCenter data not found");
|
|
}
|
|
|
|
dispatch({
|
|
type: "CREATE_DATA_CENTER_SUCCESS",
|
|
payload: response.data.data.createDataCenter,
|
|
});
|
|
|
|
return response.data.data.createDataCenter;
|
|
} catch (error) {
|
|
console.error("Error creating data center:", error);
|
|
dispatch({
|
|
type: "CREATE_DATA_CENTER_ERROR",
|
|
payload: {
|
|
error: error.message || "Failed to create data center",
|
|
},
|
|
});
|
|
throw error;
|
|
}
|
|
};
|
|
};
|
|
|
|
export const updateDataCenter = (id, dataCenterData) => {
|
|
return async (dispatch) => {
|
|
dispatch({
|
|
type: "UPDATE_DATA_CENTER_LOADING",
|
|
});
|
|
|
|
try {
|
|
const response = await ApplicationService.http().post(
|
|
"/graphql",
|
|
{
|
|
query: `
|
|
mutation UpdateDataCenter($id: ID!, $input: DataCenterUpdateInput!) {
|
|
updateDataCenter(id: $id, input: $input) {
|
|
id
|
|
dataCenter
|
|
externalId
|
|
ayposURL
|
|
number
|
|
address
|
|
latitude
|
|
longitude
|
|
area {
|
|
id
|
|
tag
|
|
cities {
|
|
id
|
|
name
|
|
}
|
|
districts {
|
|
id
|
|
name
|
|
}
|
|
}
|
|
city {
|
|
id
|
|
name
|
|
}
|
|
emissionScope {
|
|
id
|
|
tag
|
|
description
|
|
}
|
|
sector {
|
|
id
|
|
tag
|
|
}
|
|
subSector {
|
|
id
|
|
tag
|
|
}
|
|
dataCenterEmissionSources {
|
|
id
|
|
emissionSource {
|
|
id
|
|
tag
|
|
}
|
|
consuptionUnit {
|
|
id
|
|
description
|
|
}
|
|
isDefault
|
|
percentage
|
|
}
|
|
activitySubUnit {
|
|
id
|
|
tag
|
|
}
|
|
}
|
|
}
|
|
`,
|
|
variables: {
|
|
id: id,
|
|
input: {
|
|
dataCenter: dataCenterData.name,
|
|
externalId: parseInt(dataCenterData.externalId),
|
|
ayposURL: dataCenterData.ayposURL || "",
|
|
number: parseInt(dataCenterData.number) || 1,
|
|
areaId: dataCenterData.areaId || null,
|
|
cityId: dataCenterData.cityId || null,
|
|
address: dataCenterData.address || "",
|
|
latitude: dataCenterData.latitude
|
|
? parseFloat(dataCenterData.latitude)
|
|
: null,
|
|
longitude: dataCenterData.longitude
|
|
? parseFloat(dataCenterData.longitude)
|
|
: null,
|
|
emissionScopeId: dataCenterData.emissionScopeId || null,
|
|
sectorId: dataCenterData.sectorId || null,
|
|
subSectorId: dataCenterData.subSectorId || null,
|
|
dataCenterEmissionSources:
|
|
dataCenterData.dataCenterEmissionSources || [],
|
|
activitySubUnitId: dataCenterData.activitySubUnitId || null,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: "Bearer " + localStorage.getItem("accessToken"),
|
|
},
|
|
}
|
|
);
|
|
|
|
if (response.data?.errors) {
|
|
throw new Error(response.data.errors[0].message);
|
|
}
|
|
|
|
dispatch({
|
|
type: "UPDATE_DATA_CENTER_SUCCESS",
|
|
payload: response.data.data.updateDataCenter,
|
|
});
|
|
|
|
return response.data.data.updateDataCenter;
|
|
} catch (error) {
|
|
console.error("Error updating data center:", error);
|
|
dispatch({
|
|
type: "UPDATE_DATA_CENTER_ERROR",
|
|
payload: {
|
|
error: error.message || "Failed to update data center",
|
|
},
|
|
});
|
|
throw error;
|
|
}
|
|
};
|
|
};
|
|
|
|
export const deleteDataCenter = (id) => {
|
|
return async (dispatch) => {
|
|
dispatch({
|
|
type: "DELETE_DATA_CENTER_LOADING",
|
|
});
|
|
|
|
try {
|
|
const response = await ApplicationService.http().post(
|
|
"/graphql",
|
|
{
|
|
query: `
|
|
mutation DeleteDataCenter($id: ID!) {
|
|
deleteDataCenter(id: $id)
|
|
}
|
|
`,
|
|
variables: {
|
|
id: id,
|
|
},
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: "Bearer " + localStorage.getItem("accessToken"),
|
|
},
|
|
}
|
|
);
|
|
|
|
if (response.data?.errors) {
|
|
throw new Error(response.data.errors[0].message);
|
|
}
|
|
|
|
dispatch({
|
|
type: "DELETE_DATA_CENTER_SUCCESS",
|
|
payload: id,
|
|
});
|
|
|
|
return true;
|
|
} catch (error) {
|
|
console.error("Error deleting data center:", error);
|
|
dispatch({
|
|
type: "DELETE_DATA_CENTER_ERROR",
|
|
payload: {
|
|
error: error.message || "Failed to delete data center",
|
|
},
|
|
});
|
|
throw error;
|
|
}
|
|
};
|
|
};
|
|
|
|
export const getEmissionScopes = () => {
|
|
return async (dispatch) => {
|
|
dispatch({
|
|
type: "GET_EMISSION_SCOPES_LOADING",
|
|
});
|
|
|
|
try {
|
|
const response = await ApplicationService.http().post(
|
|
"/graphql",
|
|
{
|
|
query: `
|
|
query GetEmissionScopes {
|
|
emissionScopes {
|
|
id
|
|
tag
|
|
description
|
|
}
|
|
}
|
|
`,
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: "Bearer " + localStorage.getItem("accessToken"),
|
|
},
|
|
}
|
|
);
|
|
|
|
if (response.data?.errors) {
|
|
throw new Error(response.data.errors[0].message);
|
|
}
|
|
|
|
dispatch({
|
|
type: "GET_EMISSION_SCOPES_SUCCESS",
|
|
payload: response.data.data.emissionScopes,
|
|
});
|
|
|
|
return response.data.data.emissionScopes;
|
|
} catch (error) {
|
|
console.error("Error fetching emission scopes:", error);
|
|
dispatch({
|
|
type: "GET_EMISSION_SCOPES_ERROR",
|
|
payload: {
|
|
error: error.message || "Failed to fetch emission scopes",
|
|
},
|
|
});
|
|
throw error;
|
|
}
|
|
};
|
|
};
|
|
|
|
export const getDataCenterVMs = (dataCenterId) => {
|
|
return new Promise(async (resolve, reject) => {
|
|
// Don't make the request if dataCenterId is undefined, null, or empty
|
|
if (!dataCenterId || dataCenterId === "undefined") {
|
|
console.log("getDataCenterVMs: No dataCenterId provided");
|
|
resolve([]);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
console.log(
|
|
"getDataCenterVMs: Fetching VMs for data center:",
|
|
dataCenterId
|
|
);
|
|
const response = await ApplicationService.http().post(
|
|
"/graphql",
|
|
{
|
|
query: `
|
|
{
|
|
dataCenter(id: "${dataCenterId}") {
|
|
id
|
|
dataCenter
|
|
physicalMachines {
|
|
id
|
|
name
|
|
vms {
|
|
id
|
|
vmName
|
|
state
|
|
power
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`,
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: "Bearer " + localStorage.getItem("accessToken"),
|
|
},
|
|
}
|
|
);
|
|
|
|
const dataCenter = response?.data?.data?.dataCenter;
|
|
console.log("getDataCenterVMs: Data center response:", dataCenter);
|
|
|
|
let allVMs = [];
|
|
|
|
if (dataCenter && dataCenter.physicalMachines) {
|
|
dataCenter.physicalMachines.forEach((pm) => {
|
|
if (pm.vms) {
|
|
allVMs = allVMs.concat(pm.vms);
|
|
}
|
|
});
|
|
}
|
|
|
|
console.log("getDataCenterVMs: Found VMs:", allVMs);
|
|
resolve(allVMs);
|
|
} catch (error) {
|
|
console.error("Error fetching VMs by data center:", error);
|
|
resolve([]);
|
|
}
|
|
});
|
|
};
|