8535197168

Committed 03 Apr 2024 07:58AM CUT coverage: 90.342% (-2.2%) from 92.496%

Build # 8535197168

Build Type

Pull #6881

github

Committed by

web-flow

Commit Message

Merge a1722af93 into 6be2ede5e

Pull Request Pull Request #6881: [PUI] Add coverage testing

Run Details

227 of 631 branches covered (35.97%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

31971 of 35009 relevant lines covered (91.32%)

1.12 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

12.86

/src/frontend/src/states/SettingsState.tsx

/**
 * State management for remote (server side) settings
 */
import { create, createStore } from 'zustand';

import { api } from '../App';
import { ApiEndpoints } from '../enums/ApiEndpoints';
import { isTrue } from '../functions/conversion';
import { PathParams, apiUrl } from './ApiState';
import { useSessionState } from './SessionState';
import { Setting, SettingsLookup } from './states';

export interface SettingsStateProps {
  settings: Setting[];
  lookup: SettingsLookup;
  fetchSettings: () => void;
  endpoint: ApiEndpoints;
  pathParams?: PathParams;
  getSetting: (key: string, default_value?: string) => string; // Return a raw setting value
  isSet: (key: string, default_value?: boolean) => boolean; // Check a "boolean" setting
}

/**
 * State management for global (server side) settings
 */
export const useGlobalSettingsState = create<SettingsStateProps>(
  (set, get) => ({
    settings: [],
    lookup: {},
    endpoint: ApiEndpoints.settings_global_list,
    fetchSettings: async () => {
      if (!useSessionState.getState().hasToken()) {
        return;
      }

      await api
        .get(apiUrl(ApiEndpoints.settings_global_list))
        .then((response) => {
          set({
            settings: response.data,
            lookup: generate_lookup(response.data)
          });
        })
        .catch((_error) => {
          console.error('Error fetching global settings');
        });
    },
    getSetting: (key: string, default_value?: string) => {
      return get().lookup[key] ?? default_value ?? '';
    },
    isSet: (key: string, default_value?: boolean) => {
      let value = get().lookup[key] ?? default_value ?? 'false';
      return isTrue(value);
    }
  })
);

/**
 * State management for user (server side) settings
 */
export const useUserSettingsState = create<SettingsStateProps>((set, get) => ({
  settings: [],
  lookup: {},
  endpoint: ApiEndpoints.settings_user_list,
  fetchSettings: async () => {
    if (!useSessionState.getState().hasToken()) {
      return;
    }

    await api
      .get(apiUrl(ApiEndpoints.settings_user_list))
      .then((response) => {
        set({
          settings: response.data,
          lookup: generate_lookup(response.data)
        });
      })
      .catch((_error) => {
        console.error('Error fetching user settings');
      });
  },
  getSetting: (key: string, default_value?: string) => {
    return get().lookup[key] ?? default_value ?? '';
  },
  isSet: (key: string, default_value?: boolean) => {
    let value = get().lookup[key] ?? default_value ?? 'false';
    return isTrue(value);
  }
}));

/**
 * State management for plugin settings
 */
interface CreatePluginSettingStateProps {
  plugin: string;
}

export const createPluginSettingsState = ({
  plugin
}: CreatePluginSettingStateProps) => {
  const pathParams: PathParams = { plugin };

  return createStore<SettingsStateProps>()((set, get) => ({
    settings: [],
    lookup: {},
    endpoint: ApiEndpoints.plugin_setting_list,
    pathParams,
    fetchSettings: async () => {
      await api
        .get(apiUrl(ApiEndpoints.plugin_setting_list, undefined, { plugin }))
        .then((response) => {
          const settings = response.data;
          set({
            settings,
            lookup: generate_lookup(settings)
          });
        })
        .catch((_error) => {
          console.error(`Error fetching plugin settings for plugin ${plugin}`);
        });
    },
    getSetting: (key: string, default_value?: string) => {
      return get().lookup[key] ?? default_value ?? '';
    },
    isSet: (key: string, default_value?: boolean) => {
      let value = get().lookup[key] ?? default_value ?? 'false';
      return isTrue(value);
    }
  }));
};

/**
 * State management for machine settings
 */
interface CreateMachineSettingStateProps {
  machine: string;
  configType: 'M' | 'D';
}

export const createMachineSettingsState = ({
  machine,
  configType
}: CreateMachineSettingStateProps) => {
  const pathParams: PathParams = { machine, config_type: configType };

  return createStore<SettingsStateProps>()((set, get) => ({
    settings: [],
    lookup: {},
    endpoint: ApiEndpoints.machine_setting_detail,
    pathParams,
    fetchSettings: async () => {
      await api
        .get(apiUrl(ApiEndpoints.machine_setting_list, undefined, { machine }))
        .then((response) => {
          const settings = response.data.filter(
            (s: any) => s.config_type === configType
          );
          set({
            settings,
            lookup: generate_lookup(settings)
          });
        })
        .catch((error) => {
          console.error(
            `Error fetching machine settings for machine ${machine} with type ${configType}:`,
            error
          );
        });
    },
    getSetting: (key: string, default_value?: string) => {
      return get().lookup[key] ?? default_value ?? '';
    },
    isSet: (key: string, default_value?: boolean) => {
      let value = get().lookup[key] ?? default_value ?? 'false';
      return isTrue(value);
    }
  }));
};

/*
  return a lookup dictionary for the value of the provided Setting list
*/
function generate_lookup(data: Setting[]) {
  let lookup_dir: SettingsLookup = {};
  for (let setting of data) {
    lookup_dir[setting.key] = setting.value;
  }
  return lookup_dir;
}

1	/**
2	* State management for remote (server side) settings
3	*/
4	import { create, createStore } from 'zustand';
5
6	import { api } from '../App';
7	import { ApiEndpoints } from '../enums/ApiEndpoints';
8	import { isTrue } from '../functions/conversion';
9	import { PathParams, apiUrl } from './ApiState';
10	import { useSessionState } from './SessionState';
11	import { Setting, SettingsLookup } from './states';
12
13	export interface SettingsStateProps {
14	settings: Setting[];
15	lookup: SettingsLookup;
16	fetchSettings: () => void;
17	endpoint: ApiEndpoints;
18	pathParams?: PathParams;
19	getSetting: (key: string, default_value?: string) => string; // Return a raw setting value
20	isSet: (key: string, default_value?: boolean) => boolean; // Check a "boolean" setting
21	}
22
23	/**
24	* State management for global (server side) settings
25	*/
26	export const useGlobalSettingsState = create<SettingsStateProps>(	4✔
27	(set, get) => ({	4✔
28	settings: [],
29	lookup: {},
30	endpoint: ApiEndpoints.settings_global_list,
31	fetchSettings: async () => {
32	if (!useSessionState.getState().hasToken()) {	7!
33	return;	×
34	}
35
36	await api	7✔
37	.get(apiUrl(ApiEndpoints.settings_global_list))
38	.then((response) => {
39	set({	×
40	settings: response.data,
41	lookup: generate_lookup(response.data)
42	});
43	})
44	.catch((_error) => {
45	console.error('Error fetching global settings');	×
46	});
47	},
48	getSetting: (key: string, default_value?: string) => {
49	return get().lookup[key] ?? default_value ?? '';	×
50	},
51	isSet: (key: string, default_value?: boolean) => {
52	let value = get().lookup[key] ?? default_value ?? 'false';	×
53	return isTrue(value);	×
54	}
55	})
56	);
57
58	/**
59	* State management for user (server side) settings
60	*/
61	export const useUserSettingsState = create<SettingsStateProps>((set, get) => ({	4✔
62	settings: [],
63	lookup: {},
64	endpoint: ApiEndpoints.settings_user_list,
65	fetchSettings: async () => {
66	if (!useSessionState.getState().hasToken()) {	7!
67	return;	×
68	}
69
70	await api	7✔
71	.get(apiUrl(ApiEndpoints.settings_user_list))
72	.then((response) => {
73	set({	×
74	settings: response.data,
75	lookup: generate_lookup(response.data)
76	});
77	})
78	.catch((_error) => {
79	console.error('Error fetching user settings');	×
80	});
81	},
82	getSetting: (key: string, default_value?: string) => {
83	return get().lookup[key] ?? default_value ?? '';	×
84	},
85	isSet: (key: string, default_value?: boolean) => {
86	let value = get().lookup[key] ?? default_value ?? 'false';	×
87	return isTrue(value);	×
88	}
89	}));
90
91	/**
92	* State management for plugin settings
93	*/
94	interface CreatePluginSettingStateProps {
95	plugin: string;
96	}
97
98	export const createPluginSettingsState = ({	4✔
99	plugin
100	}: CreatePluginSettingStateProps) => {
101	const pathParams: PathParams = { plugin };	×
102
103	return createStore<SettingsStateProps>()((set, get) => ({	×
104	settings: [],
105	lookup: {},
106	endpoint: ApiEndpoints.plugin_setting_list,
107	pathParams,
108	fetchSettings: async () => {
109	await api	×
110	.get(apiUrl(ApiEndpoints.plugin_setting_list, undefined, { plugin }))
111	.then((response) => {
112	const settings = response.data;	×
113	set({	×
114	settings,
115	lookup: generate_lookup(settings)
116	});
117	})
118	.catch((_error) => {
119	console.error(`Error fetching plugin settings for plugin ${plugin}`);	×
120	});
121	},
122	getSetting: (key: string, default_value?: string) => {
123	return get().lookup[key] ?? default_value ?? '';	×
124	},
125	isSet: (key: string, default_value?: boolean) => {
126	let value = get().lookup[key] ?? default_value ?? 'false';	×
127	return isTrue(value);	×
128	}
129	}));
130	};
131
132	/**
133	* State management for machine settings
134	*/
135	interface CreateMachineSettingStateProps {
136	machine: string;
137	configType: 'M' \| 'D';
138	}
139
140	export const createMachineSettingsState = ({	4✔
141	machine,
142	configType
143	}: CreateMachineSettingStateProps) => {
144	const pathParams: PathParams = { machine, config_type: configType };	×
145
146	return createStore<SettingsStateProps>()((set, get) => ({	×
147	settings: [],
148	lookup: {},
149	endpoint: ApiEndpoints.machine_setting_detail,
150	pathParams,
151	fetchSettings: async () => {
152	await api	×
153	.get(apiUrl(ApiEndpoints.machine_setting_list, undefined, { machine }))
154	.then((response) => {
155	const settings = response.data.filter(	×
156	(s: any) => s.config_type === configType	×
157	);
158	set({	×
159	settings,
160	lookup: generate_lookup(settings)
161	});
162	})
163	.catch((error) => {
164	console.error(	×
165	`Error fetching machine settings for machine ${machine} with type ${configType}:`,
166	error
167	);
168	});
169	},
170	getSetting: (key: string, default_value?: string) => {
171	return get().lookup[key] ?? default_value ?? '';	×
172	},
173	isSet: (key: string, default_value?: boolean) => {
174	let value = get().lookup[key] ?? default_value ?? 'false';	×
175	return isTrue(value);	×
176	}
177	}));
178	};
179
180	/*
181	return a lookup dictionary for the value of the provided Setting list
182	*/
183	function generate_lookup(data: Setting[]) {
184	let lookup_dir: SettingsLookup = {};	×
185	for (let setting of data) {	×
186	lookup_dir[setting.key] = setting.value;	×
187	}
188	return lookup_dir;	×
189	}

inventree / InvenTree / 8535197168

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous