GithubRepository,
GitlabProject
} from '../types/alm-integration';
+import { Paging } from '../types/types';
import { ProjectBase } from './components';
export function setAlmPersonalAccessToken(
pageSize: number;
page?: number;
query?: string;
-}): Promise<{ repositories: GithubRepository[]; paging: T.Paging }> {
+}): Promise<{ repositories: GithubRepository[]; paging: Paging }> {
const { almSetting, organization, pageSize, page = 1, query } = data;
return getJSON('/api/alm_integrations/list_github_repositories', {
almSetting,
page?: number;
pageSize?: number;
query?: string;
-}): Promise<{ projects: GitlabProject[]; projectsPaging: T.Paging }> {
+}): Promise<{ projects: GitlabProject[]; projectsPaging: Paging }> {
const { almSetting, pageSize, page, query } = data;
return getJSON('/api/alm_integrations/search_gitlab_repos', {
almSetting,
import { getJSON, post, postJSON, RequestData } from '../helpers/request';
import { BranchParameters } from '../types/branch-like';
import { ComponentQualifier, TreeComponent, TreeComponentWithPath } from '../types/component';
+import {
+ ComponentMeasure,
+ Dict,
+ DuplicatedFile,
+ Duplication,
+ Metric,
+ MyProject,
+ Paging,
+ SourceLine,
+ SourceViewerFile,
+ Visibility
+} from '../types/types';
export interface BaseSearchProjectsParameters {
analyzedBefore?: string;
projects?: string;
q?: string;
qualifiers?: string;
- visibility?: T.Visibility;
+ visibility?: Visibility;
}
export interface ProjectBase {
key: string;
name: string;
qualifier: string;
- visibility: T.Visibility;
+ visibility: Visibility;
}
export interface Project extends ProjectBase {
parameters: SearchProjectsParameters
): Promise<{
components: Project[];
- paging: T.Paging;
+ paging: Paging;
}> {
return getJSON('/api/projects/search', parameters);
}
export function createProject(data: {
name: string;
project: string;
- visibility?: T.Visibility;
+ visibility?: Visibility;
}): Promise<{ project: ProjectBase }> {
return postJSON('/api/projects/create', data).catch(throwGlobalError);
}
metrics: string[] = [],
additional: RequestData = {}
): Promise<{
- baseComponent: T.ComponentMeasure;
- components: T.ComponentMeasure[];
- metrics: T.Metric[];
- paging: T.Paging;
+ baseComponent: ComponentMeasure;
+ components: ComponentMeasure[];
+ metrics: Metric[];
+ paging: Paging;
}> {
const url = '/api/measures/component_tree';
const data = { ...additional, component, metricKeys: metrics.join(','), strategy };
export function getComponent(
data: { component: string; metricKeys: string } & BranchParameters
-): Promise<{ component: T.ComponentMeasure }> {
+): Promise<{ component: ComponentMeasure }> {
return getJSON('/api/measures/component', data);
}
export function getTree<T = TreeComponent>(
data: GetTreeParams & { qualifiers?: string }
-): Promise<{ baseComponent: TreeComponent; components: T[]; paging: T.Paging }> {
+): Promise<{ baseComponent: TreeComponent; components: T[]; paging: Paging }> {
return getJSON('/api/components/tree', data).catch(throwGlobalError);
}
export function getMyProjects(data: {
p?: number;
ps?: number;
-}): Promise<{ paging: T.Paging; projects: T.MyProject[] }> {
+}): Promise<{ paging: Paging; projects: MyProject[] }> {
return getJSON('/api/projects/search_my_projects', data);
}
analysisDate?: string;
qualifier: ComponentQualifier;
tags: string[];
- visibility: T.Visibility;
+ visibility: Visibility;
leakPeriodDate?: string;
needIssueSync?: boolean;
}
): Promise<{
components: Component[];
facets: Facet[];
- paging: T.Paging;
+ paging: Paging;
}> {
const url = '/api/components/search_projects';
return getJSON(url, data);
export function getComponentForSourceViewer(
data: { component: string } & BranchParameters
-): Promise<T.SourceViewerFile> {
+): Promise<SourceViewerFile> {
return getJSON('/api/components/app', data);
}
export function getSources(
data: { key: string; from?: number; to?: number } & BranchParameters
-): Promise<T.SourceLine[]> {
+): Promise<SourceLine[]> {
return getJSON('/api/sources/lines', data).then(r => r.sources);
}
export function getDuplications(
data: { key: string } & BranchParameters
-): Promise<{ duplications: T.Duplication[]; files: T.Dict<T.DuplicatedFile> }> {
+): Promise<{ duplications: Duplication[]; files: Dict<DuplicatedFile> }> {
return getJSON('/api/duplications/show', data).catch(throwGlobalError);
}
import getCoverageStatus from '../components/SourceViewer/helpers/getCoverageStatus';
import { getJSON, post, postJSON, RequestData } from '../helpers/request';
import { IssueResponse, RawIssuesResponse } from '../types/issues';
+import { Dict, FacetValue, IssueChangelog, SnippetsByComponent, SourceLine } from '../types/types';
type FacetName =
| 'assigned_to_me'
query: RequestData,
facets: FacetName[]
): Promise<{
- facets: Array<{ property: string; values: T.FacetValue[] }>;
+ facets: Array<{ property: string; values: FacetValue[] }>;
response: RawIssuesResponse;
}> {
const data = {
.catch(throwGlobalError);
}
-export function getIssueChangelog(issue: string): Promise<{ changelog: T.IssueChangelog[] }> {
+export function getIssueChangelog(issue: string): Promise<{ changelog: IssueChangelog[] }> {
return getJSON('/api/issues/changelog', { issue }).catch(throwGlobalError);
}
return getJSON('/api/issues/authors', data).then(r => r.authors, throwGlobalError);
}
-export function getIssueFlowSnippets(issueKey: string): Promise<T.Dict<T.SnippetsByComponent>> {
+export function getIssueFlowSnippets(issueKey: string): Promise<Dict<SnippetsByComponent>> {
return getJSON('/api/sources/issue_snippets', { issueKey }).then(result => {
Object.keys(result).forEach(k => {
if (result[k].sources) {
result[k].sources = result[k].sources.reduce(
- (lineMap: T.Dict<T.SourceLine>, line: T.SourceLine) => {
+ (lineMap: Dict<SourceLine>, line: SourceLine) => {
line.coverageStatus = getCoverageStatus(line);
lineMap[line.line] = line;
return lineMap;
*/
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON } from '../helpers/request';
+import { Language } from '../types/types';
-export function getLanguages(): Promise<T.Language[]> {
+export function getLanguages(): Promise<Language[]> {
return getJSON('/api/languages/list').then(r => r.languages, throwGlobalError);
}
MeasuresAndMetaWithPeriod,
MeasuresForProjects
} from '../types/measures';
+import { Measure } from '../types/types';
const COMPONENT_URL = '/api/measures/component';
export function getMeasures(
data: { component: string; metricKeys: string } & BranchParameters
-): Promise<T.Measure[]> {
+): Promise<Measure[]> {
return getJSON(COMPONENT_URL, data).then(r => r.component.measures, throwGlobalError);
}
*/
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON } from '../helpers/request';
+import { Metric } from '../types/types';
export interface MetricsResponse {
- metrics: T.Metric[];
+ metrics: Metric[];
p: number;
ps: number;
total: number;
isCustom?: boolean;
p?: number;
ps?: number;
-}): Promise<T.Metric[]> {
+}): Promise<Metric[]> {
return inner(data);
function inner(
data: { p?: number; ps?: number } = { ps: 500 },
prev?: MetricsResponse
- ): Promise<T.Metric[]> {
+ ): Promise<Metric[]> {
return getMetrics(data).then(r => {
const result = prev ? prev.metrics.concat(r.metrics) : r.metrics;
if (r.p * r.ps >= r.total) {
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON } from '../helpers/request';
import { BranchParameters } from '../types/branch-like';
+import { Component } from '../types/types';
-type NavComponent = T.Omit<T.Component, 'alm' | 'qualifier' | 'leakPeriodDate' | 'path' | 'tags'>;
+type NavComponent = Omit<Component, 'alm' | 'qualifier' | 'leakPeriodDate' | 'path' | 'tags'>;
export function getComponentNavigation(
data: { component: string } & BranchParameters
*/
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON, post } from '../helpers/request';
+import { NewCodePeriod, NewCodePeriodBranch, NewCodePeriodSettingType } from '../types/types';
export function getNewCodePeriod(data?: {
project?: string;
branch?: string;
-}): Promise<T.Omit<T.NewCodePeriod, 'effectiveValue'>> {
+}): Promise<Omit<NewCodePeriod, 'effectiveValue'>> {
return getJSON('/api/new_code_periods/show', data).catch(throwGlobalError);
}
export function setNewCodePeriod(data: {
project?: string;
branch?: string;
- type: T.NewCodePeriodSettingType;
+ type: NewCodePeriodSettingType;
value?: string;
}): Promise<void> {
return post('/api/new_code_periods/set', data).catch(throwGlobalError);
export function listBranchesNewCodePeriod(data: {
project: string;
-}): Promise<{ newCodePeriods: T.NewCodePeriodBranch[] }> {
+}): Promise<{ newCodePeriods: NewCodePeriodBranch[] }> {
return getJSON('/api/new_code_periods/list', data).catch(throwGlobalError);
}
*/
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON, post } from '../helpers/request';
+import { Notification } from '../types/types';
export function getNotifications(): Promise<{
channels: string[];
globalTypes: string[];
- notifications: T.Notification[];
+ notifications: Notification[];
perProjectTypes: string[];
}> {
return getJSON('/api/notifications/list').catch(throwGlobalError);
*/
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON, post, postJSON, RequestData } from '../helpers/request';
+import {
+ Paging,
+ PermissionGroup,
+ PermissionTemplate,
+ PermissionUser,
+ Visibility
+} from '../types/types';
import { BaseSearchProjectsParameters } from './components';
const PAGE_SIZE = 100;
}
interface GetPermissionTemplatesResponse {
- permissionTemplates: T.PermissionTemplate[];
+ permissionTemplates: PermissionTemplate[];
defaultTemplates: Array<{ templateId: string; qualifier: string }>;
permissions: Array<{ key: string; name: string; description: string }>;
}
permission?: string;
p?: number;
ps?: number;
-}): Promise<{ paging: T.Paging; users: T.PermissionUser[] }> {
+}): Promise<{ paging: Paging; users: PermissionUser[] }> {
if (!data.ps) {
data.ps = PAGE_SIZE;
}
permission?: string;
p?: number;
ps?: number;
-}): Promise<{ paging: T.Paging; groups: T.PermissionGroup[] }> {
+}): Promise<{ paging: Paging; groups: PermissionGroup[] }> {
if (!data.ps) {
data.ps = PAGE_SIZE;
}
permission?: string;
p?: number;
ps?: number;
-}): Promise<{ paging: T.Paging; users: T.PermissionUser[] }> {
+}): Promise<{ paging: Paging; users: PermissionUser[] }> {
if (!data.ps) {
data.ps = PAGE_SIZE;
}
permission?: string;
p?: number;
ps?: number;
-}): Promise<{ paging: T.Paging; groups: T.PermissionGroup[] }> {
+}): Promise<{ paging: Paging; groups: PermissionGroup[] }> {
if (!data.ps) {
data.ps = PAGE_SIZE;
}
export function changeProjectVisibility(
project: string,
- visibility: T.Visibility
+ visibility: Visibility
): Promise<void | Response> {
return post('/api/projects/update_visibility', { project, visibility }).catch(throwGlobalError);
}
export function changeProjectDefaultVisibility(
- projectVisibility: T.Visibility
+ projectVisibility: Visibility
): Promise<void | Response> {
return post('/api/projects/update_default_visibility', { projectVisibility }).catch(
throwGlobalError
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON, post, postJSON, RequestData } from '../helpers/request';
import { BranchParameters } from '../types/branch-like';
+import { Analysis, Paging } from '../types/types';
export function getProjectActivity(
data: {
p?: number;
ps?: number;
} & BranchParameters
-): Promise<{ analyses: T.Analysis[]; paging: T.Paging }> {
+): Promise<{ analyses: Analysis[]; paging: Paging }> {
return getJSON('/api/project_analyses/search', data).catch(throwGlobalError);
}
*/
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON, post, postJSON } from '../helpers/request';
+import { ProjectLink } from '../types/types';
-export function getProjectLinks(projectKey: string): Promise<T.ProjectLink[]> {
+export function getProjectLinks(projectKey: string): Promise<ProjectLink[]> {
return getJSON('/api/project_links/search', { projectKey }).then(r => r.links, throwGlobalError);
}
name: string;
projectKey: string;
url: string;
-}): Promise<T.ProjectLink> {
+}): Promise<ProjectLink> {
return postJSON('/api/project_links/create', data).then(r => r.link, throwGlobalError);
}
QualityGateProjectStatus,
SearchPermissionsParameters
} from '../types/quality-gates';
+import { Condition, Paging, QualityGate, UserBase } from '../types/types';
export function fetchQualityGates(): Promise<{
actions: { create: boolean };
- qualitygates: T.QualityGate[];
+ qualitygates: QualityGate[];
}> {
return getJSON('/api/qualitygates/list').catch(throwGlobalError);
}
-export function fetchQualityGate(data: { id: number | string }): Promise<T.QualityGate> {
+export function fetchQualityGate(data: { id: number | string }): Promise<QualityGate> {
return getJSON('/api/qualitygates/show', data).catch(throwGlobalError);
}
-export function createQualityGate(data: { name: string }): Promise<T.QualityGate> {
+export function createQualityGate(data: { name: string }): Promise<QualityGate> {
return postJSON('/api/qualitygates/create', data).catch(throwGlobalError);
}
return post('/api/qualitygates/rename', data).catch(throwGlobalError);
}
-export function copyQualityGate(data: { id: string; name: string }): Promise<T.QualityGate> {
+export function copyQualityGate(data: { id: string; name: string }): Promise<QualityGate> {
return postJSON('/api/qualitygates/copy', data).catch(throwGlobalError);
}
export function createCondition(
data: {
gateId: string;
- } & T.Omit<T.Condition, 'id'>
-): Promise<T.Condition> {
+ } & Omit<Condition, 'id'>
+): Promise<Condition> {
return postJSON('/api/qualitygates/create_condition', data).catch(throwGlobalError);
}
-export function updateCondition(data: T.Condition): Promise<T.Condition> {
+export function updateCondition(data: Condition): Promise<Condition> {
return postJSON('/api/qualitygates/update_condition', data).catch(throwGlobalError);
}
return post('/api/qualitygates/delete_condition', data);
}
-export function getGateForProject(data: { project: string }): Promise<T.QualityGate | undefined> {
+export function getGateForProject(data: { project: string }): Promise<QualityGate | undefined> {
return getJSON('/api/qualitygates/get_by_project', data).then(
({ qualityGate }) =>
qualityGate && {
query?: string;
selected?: string;
}): Promise<{
- paging: T.Paging;
+ paging: Paging;
results: Array<{ key: string; name: string; selected: boolean }>;
}> {
return getJSON('/api/qualitygates/search', data).catch(throwGlobalError);
return post('/api/qualitygates/remove_user', data).catch(throwGlobalError);
}
-export function searchUsers(data: SearchPermissionsParameters): Promise<{ users: T.UserBase[] }> {
+export function searchUsers(data: SearchPermissionsParameters): Promise<{ users: UserBase[] }> {
return getJSON('/api/qualitygates/search_users', data).catch(throwGlobalError);
}
import { Exporter, ProfileChangelogEvent } from '../apps/quality-profiles/types';
import { csvEscape } from '../helpers/csv';
import { getJSON, post, postJSON, RequestData } from '../helpers/request';
+import { Dict, Paging, ProfileInheritanceDetails, UserSelected } from '../types/types';
export interface ProfileActions {
associateProjects?: boolean;
export function getProfileProjects(
data: RequestData
-): Promise<{ more: boolean; paging: T.Paging; results: ProfileProject[] }> {
+): Promise<{ more: boolean; paging: Paging; results: ProfileProject[] }> {
return getJSON('/api/qualityprofiles/projects', data).catch(throwGlobalError);
}
language,
name: qualityProfile
}: Profile): Promise<{
- ancestors: T.ProfileInheritanceDetails[];
- children: T.ProfileInheritanceDetails[];
- profile: T.ProfileInheritanceDetails;
+ ancestors: ProfileInheritanceDetails[];
+ children: ProfileInheritanceDetails[];
+ profile: ProfileInheritanceDetails;
}> {
return getJSON('/api/qualityprofiles/inheritance', {
language,
modified: Array<{
key: string;
name: string;
- left: { params: T.Dict<string>; severity: string };
- right: { params: T.Dict<string>; severity: string };
+ left: { params: Dict<string>; severity: string };
+ right: { params: Dict<string>; severity: string };
}>;
}
}
interface SearchUsersResponse {
- users: T.UserSelected[];
- paging: T.Paging;
+ users: UserSelected[];
+ paging: Paging;
}
export function searchUsers(parameters: SearchUsersGroupsParameters): Promise<SearchUsersResponse> {
export interface SearchGroupsResponse {
groups: Array<{ name: string }>;
- paging: T.Paging;
+ paging: Paging;
}
export function searchGroups(
export function activateRule(data: {
key: string;
- params?: T.Dict<string>;
+ params?: Dict<string>;
reset?: boolean;
rule: string;
severity?: string;
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON, post, postJSON } from '../helpers/request';
import { GetRulesAppResponse, SearchRulesResponse } from '../types/coding-rules';
+import { RuleActivation, RuleDetails } from '../types/types';
export function getRulesApp(): Promise<GetRulesAppResponse> {
return getJSON('/api/rules/app').catch(throwGlobalError);
export function getRuleDetails(parameters: {
actives?: boolean;
key: string;
-}): Promise<{ actives?: T.RuleActivation[]; rule: T.RuleDetails }> {
+}): Promise<{ actives?: RuleActivation[]; rule: RuleDetails }> {
return getJSON('/api/rules/show', parameters).catch(throwGlobalError);
}
status?: string;
template_key: string;
type?: string;
-}): Promise<T.RuleDetails> {
+}): Promise<RuleDetails> {
return postJSON('/api/rules/create', data).then(
r => r.rule,
response => {
severity?: string;
status?: string;
tags?: string;
-}): Promise<T.RuleDetails> {
+}): Promise<RuleDetails> {
return postJSON('/api/rules/update', data).then(r => r.rule, throwGlobalError);
}
HotspotSetStatusRequest,
HotspotStatus
} from '../types/security-hotspots';
+import { UserBase } from '../types/types';
const HOTSPOTS_SEARCH_URL = '/api/hotspots/search';
export function getSecurityHotspotDetails(securityHotspotKey: string): Promise<Hotspot> {
return getJSON('/api/hotspots/show', { hotspot: securityHotspotKey })
- .then((response: Hotspot & { users: T.UserBase[] }) => {
+ .then((response: Hotspot & { users: UserBase[] }) => {
const { users, ...hotspot } = response;
if (users) {
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON, post, postJSON, requestTryAndRepeatUntil } from '../helpers/request';
import { SystemUpgrade } from '../types/system';
+import { SysInfoCluster, SysInfoStandalone, SysStatus } from '../types/types';
export function setLogLevel(level: string): Promise<void | Response> {
return post('/api/system/change_log_level', { level }).catch(throwGlobalError);
}
-export function getSystemInfo(): Promise<T.SysInfoCluster | T.SysInfoStandalone> {
+export function getSystemInfo(): Promise<SysInfoCluster | SysInfoStandalone> {
return getJSON('/api/system/info').catch(throwGlobalError);
}
-export function getSystemStatus(): Promise<{ id: string; version: string; status: T.SysStatus }> {
+export function getSystemStatus(): Promise<{ id: string; version: string; status: SysStatus }> {
return getJSON('/api/system/status');
}
export function waitSystemUPStatus(): Promise<{
id: string;
version: string;
- status: T.SysStatus;
+ status: SysStatus;
}> {
return requestTryAndRepeatUntil(
getSystemStatus,
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON } from '../helpers/request';
import { BranchParameters } from '../types/branch-like';
+import { Paging } from '../types/types';
interface TimeMachineResponse {
measures: {
metric: string;
history: Array<{ date: string; value?: string }>;
}[];
- paging: T.Paging;
+ paging: Paging;
}
export function getTimeMachineData(
*/
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON, post, postJSON } from '../helpers/request';
+import { NewUserToken, UserToken } from '../types/types';
/** List tokens for given user login */
-export function getTokens(login: string): Promise<T.UserToken[]> {
+export function getTokens(login: string): Promise<UserToken[]> {
return getJSON('/api/user_tokens/search', { login }).then(r => r.userTokens, throwGlobalError);
}
-export function generateToken(data: { name: string; login?: string }): Promise<T.NewUserToken> {
+export function generateToken(data: { name: string; login?: string }): Promise<NewUserToken> {
return postJSON('/api/user_tokens/generate', data).catch(throwGlobalError);
}
*/
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON, post, postJSON } from '../helpers/request';
+import { Group, Paging, UserSelected } from '../types/types';
export function searchUsersGroups(data: {
f?: string;
p?: number;
ps?: number;
q?: string;
-}): Promise<{ groups: T.Group[]; paging: T.Paging }> {
+}): Promise<{ groups: Group[]; paging: Paging }> {
return getJSON('/api/user_groups/search', data).catch(throwGlobalError);
}
ps?: number;
q?: string;
selected?: string;
-}): Promise<T.Paging & { users: T.UserSelected[] }> {
+}): Promise<Paging & { users: UserSelected[] }> {
return getJSON('/api/user_groups/users', data).catch(throwGlobalError);
}
return post('/api/user_groups/remove_user', data).catch(throwGlobalError);
}
-export function createGroup(data: { description?: string; name: string }): Promise<T.Group> {
+export function createGroup(data: { description?: string; name: string }): Promise<Group> {
return postJSON('/api/user_groups/create', data).then(r => r.group, throwGlobalError);
}
*/
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON, post, postJSON } from '../helpers/request';
+import {
+ CurrentUser,
+ CurrentUserSetting,
+ HomePage,
+ IdentityProvider,
+ Paging,
+ User
+} from '../types/types';
-export function getCurrentUser(): Promise<T.CurrentUser> {
+export function getCurrentUser(): Promise<CurrentUser> {
return getJSON('/api/users/current');
}
ps?: number;
q?: string;
selected?: string;
-}): Promise<{ paging: T.Paging; groups: UserGroup[] }> {
+}): Promise<{ paging: Paging; groups: UserGroup[] }> {
return getJSON('/api/users/groups', data);
}
-export function getIdentityProviders(): Promise<{ identityProviders: T.IdentityProvider[] }> {
+export function getIdentityProviders(): Promise<{ identityProviders: IdentityProvider[] }> {
return getJSON('/api/users/identity_providers').catch(throwGlobalError);
}
p?: number;
ps?: number;
q?: string;
-}): Promise<{ paging: T.Paging; users: T.User[] }> {
+}): Promise<{ paging: Paging; users: User[] }> {
data.q = data.q || undefined;
return getJSON('/api/users/search', data).catch(throwGlobalError);
}
login: string;
name?: string;
scmAccount: string[];
-}): Promise<T.User> {
+}): Promise<User> {
return postJSON('/api/users/update', {
...data,
scmAccount: data.scmAccount.length > 0 ? data.scmAccount : ''
});
}
-export function deactivateUser(data: { login: string }): Promise<T.User> {
+export function deactivateUser(data: { login: string }): Promise<User> {
return postJSON('/api/users/deactivate', data).catch(throwGlobalError);
}
-export function setHomePage(homepage: T.HomePage): Promise<void | Response> {
+export function setHomePage(homepage: HomePage): Promise<void | Response> {
return post('/api/users/set_homepage', homepage).catch(throwGlobalError);
}
-export function setUserSetting(setting: T.CurrentUserSetting): Promise<void | Response> {
+export function setUserSetting(setting: CurrentUserSetting): Promise<void | Response> {
return post('/api/users/set_setting', setting).catch(throwGlobalError);
}
*/
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON } from '../helpers/request';
+import { WebApi } from '../types/types';
interface RawDomain {
- actions: T.WebApi.Action[];
+ actions: WebApi.Action[];
deprecatedSince?: string;
description: string;
internal: boolean;
.catch(throwGlobalError);
}
-export function fetchResponseExample(domain: string, action: string): Promise<T.WebApi.Example> {
+export function fetchResponseExample(domain: string, action: string): Promise<WebApi.Example> {
return getJSON('/api/webservices/response_example', { controller: domain, action }).catch(
throwGlobalError
);
*/
import throwGlobalError from '../app/utils/throwGlobalError';
import { getJSON, post, postJSON } from '../helpers/request';
+import { Paging, Webhook, WebhookDelivery } from '../types/types';
export function createWebhook(data: {
name: string;
project?: string;
secret?: string;
url: string;
-}): Promise<{ webhook: T.Webhook }> {
+}): Promise<{ webhook: Webhook }> {
return postJSON('/api/webhooks/create', data).catch(throwGlobalError);
}
return post('/api/webhooks/delete', data).catch(throwGlobalError);
}
-export function searchWebhooks(data: { project?: string }): Promise<{ webhooks: T.Webhook[] }> {
+export function searchWebhooks(data: { project?: string }): Promise<{ webhooks: Webhook[] }> {
return getJSON('/api/webhooks/list', data).catch(throwGlobalError);
}
p?: number;
ps?: number;
}): Promise<{
- deliveries: T.WebhookDelivery[];
- paging: T.Paging;
+ deliveries: WebhookDelivery[];
+ paging: Paging;
}> {
return getJSON('/api/webhooks/deliveries', data).catch(throwGlobalError);
}
export function getDelivery(data: {
deliveryId: string;
-}): Promise<{ delivery: T.WebhookDelivery & { payload: string } }> {
+}): Promise<{ delivery: WebhookDelivery & { payload: string } }> {
return getJSON('/api/webhooks/delivery', data).catch(throwGlobalError);
}
import { setAdminPages } from '../../store/appState';
import { getAppState, Store } from '../../store/rootReducer';
import { PendingPluginResult } from '../../types/plugins';
+import { AppState, Extension, SysStatus } from '../../types/types';
import AdminContext, { defaultPendingPlugins, defaultSystemStatus } from './AdminContext';
import SettingsNav from './nav/settings/SettingsNav';
interface Props {
- appState: Pick<T.AppState, 'adminPages' | 'canAdmin'>;
+ appState: Pick<AppState, 'adminPages' | 'canAdmin'>;
location: {};
- setAdminPages: (adminPages: T.Extension[]) => void;
+ setAdminPages: (adminPages: Extension[]) => void;
}
interface State {
pendingPlugins: PendingPluginResult;
- systemStatus: T.SysStatus;
+ systemStatus: SysStatus;
}
export class AdminContainer extends React.PureComponent<Props, State> {
*/
import * as React from 'react';
import { PendingPluginResult } from '../../types/plugins';
+import { SysStatus } from '../../types/types';
export interface AdminContextInterface {
fetchSystemStatus: () => void;
fetchPendingPlugins: () => void;
pendingPlugins: PendingPluginResult;
- systemStatus: T.SysStatus;
+ systemStatus: SysStatus;
}
export const defaultPendingPlugins = { installing: [], removing: [], updating: [] };
import { BranchLike } from '../../types/branch-like';
import { ComponentQualifier, isPortfolioLike } from '../../types/component';
import { Task, TaskStatuses, TaskTypes, TaskWarning } from '../../types/tasks';
+import { AppState, Component, Status } from '../../types/types';
import ComponentContainerNotFound from './ComponentContainerNotFound';
import { ComponentContext } from './ComponentContext';
import PageUnavailableDueToIndexation from './indexation/PageUnavailableDueToIndexation';
import ComponentNav from './nav/component/ComponentNav';
interface Props {
- appState: Pick<T.AppState, 'branchesEnabled'>;
+ appState: Pick<AppState, 'branchesEnabled'>;
children: React.ReactElement;
location: Pick<Location, 'query' | 'pathname'>;
- registerBranchStatus: (branchLike: BranchLike, component: string, status: T.Status) => void;
+ registerBranchStatus: (branchLike: BranchLike, component: string, status: Status) => void;
requireAuthorization: (router: Pick<Router, 'replace'>) => void;
router: Pick<Router, 'replace'>;
}
interface State {
branchLike?: BranchLike;
branchLikes: BranchLike[];
- component?: T.Component;
+ component?: Component;
currentTask?: Task;
isPending: boolean;
loading: boolean;
}
};
- fetchBranches = async (componentWithQualifier: T.Component) => {
+ fetchBranches = async (componentWithQualifier: Component) => {
const breadcrumb = componentWithQualifier.breadcrumbs.find(({ qualifier }) => {
return ([ComponentQualifier.Application, ComponentQualifier.Project] as string[]).includes(
qualifier
);
};
- fetchWarnings = (component: T.Component, branchLike?: BranchLike) => {
+ fetchWarnings = (component: Component, branchLike?: BranchLike) => {
if (component.qualifier === ComponentQualifier.Project) {
getAnalysisStatus({
component: component.key,
}
};
- fetchProjectBindingErrors = async (component: T.Component) => {
+ fetchProjectBindingErrors = async (component: Component) => {
if (
component.qualifier === ComponentQualifier.Project &&
component.analysisDate === undefined &&
}
};
- addQualifier = (component: T.Component) => ({
+ addQualifier = (component: Component) => ({
...component,
qualifier: component.breadcrumbs[component.breadcrumbs.length - 1].qualifier
});
newTasksInProgress: Task[],
currentTask: Task | undefined,
newCurrentTask: Task | undefined,
- component: T.Component | undefined
+ component: Component | undefined
) => {
const progressHasChanged = Boolean(
tasksInProgress &&
needsAnotherCheck = (
shouldFetchComponent: boolean,
- component: T.Component | undefined,
+ component: Component | undefined,
newTasksInProgress: Task[]
) => {
return (
return !task.branch && !task.pullRequest;
};
- registerBranchStatuses = (branchLikes: BranchLike[], component: T.Component) => {
+ registerBranchStatuses = (branchLikes: BranchLike[], component: Component) => {
branchLikes.forEach(branchLike => {
if (branchLike.status) {
this.props.registerBranchStatus(
});
};
- handleComponentChange = (changes: Partial<T.Component>) => {
+ handleComponentChange = (changes: Partial<Component>) => {
if (this.mounted) {
this.setState(state => {
if (state.component) {
- const newComponent: T.Component = { ...state.component, ...changes };
+ const newComponent: Component = { ...state.component, ...changes };
return { component: newComponent };
}
return null;
*/
import * as React from 'react';
import { BranchLike } from '../../types/branch-like';
+import { Component } from '../../types/types';
interface ComponentContextType {
branchLike: BranchLike | undefined;
- component: T.Component | undefined;
+ component: Component | undefined;
}
export const ComponentContext = React.createContext<ComponentContextType>({
import { Router, withRouter } from '../../components/hoc/withRouter';
import { getHomePageUrl } from '../../helpers/urls';
import { isLoggedIn } from '../../helpers/users';
+import { CurrentUser } from '../../types/types';
export interface LandingProps {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
router: Router;
}
import { translate } from '../../helpers/l10n';
import { BranchLike } from '../../types/branch-like';
import { isApplication } from '../../types/component';
+import { Component } from '../../types/types';
export interface NonAdminPagesContainerProps {
children: JSX.Element;
branchLike?: BranchLike;
branchLikes: BranchLike[];
- component: T.Component;
+ component: Component;
isInProgress?: boolean;
isPending?: boolean;
onBranchesChange: () => void;
import { Permissions } from '../../types/permissions';
import { RiskConsent } from '../../types/plugins';
import { SettingsKey } from '../../types/settings';
+import { LoggedInUser } from '../../types/types';
import GlobalMessagesContainer from './GlobalMessagesContainer';
import './PluginRiskConsent.css';
export interface PluginRiskConsentProps {
- currentUser: T.LoggedInUser;
+ currentUser: LoggedInUser;
router: Router;
}
*/
import * as React from 'react';
import { BranchLike } from '../../types/branch-like';
+import { Component } from '../../types/types';
import handleRequiredAuthorization from '../utils/handleRequiredAuthorization';
import A11ySkipTarget from './a11y/A11ySkipTarget';
children: JSX.Element;
branchLike?: BranchLike;
branchLikes: BranchLike[];
- component: T.Component;
+ component: Component;
isInProgress?: boolean;
isPending?: boolean;
onBranchesChange: () => void;
import { whenLoggedIn } from '../../components/hoc/whenLoggedIn';
import { translate } from '../../helpers/l10n';
import { getBaseUrl } from '../../helpers/system';
+import { LoggedInUser } from '../../types/types';
import GlobalMessagesContainer from './GlobalMessagesContainer';
export interface ResetPasswordProps {
- currentUser: T.LoggedInUser;
+ currentUser: LoggedInUser;
}
export function ResetPassword({ currentUser }: ResetPasswordProps) {
import { isLoggedIn } from '../../helpers/users';
import { getAppState, getCurrentUser, Store } from '../../store/rootReducer';
import { EditionKey } from '../../types/editions';
+import { CurrentUser } from '../../types/types';
const LicensePromptModal = lazyLoadComponent(
() => import('../../apps/marketplace/components/LicensePromptModal'),
interface StateProps {
canAdmin?: boolean;
currentEdition?: EditionKey;
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
}
interface OwnProps {
import { AlmKeys } from '../../../types/alm-settings';
import { ComponentQualifier } from '../../../types/component';
import { TaskStatuses, TaskTypes } from '../../../types/tasks';
+import { Component } from '../../../types/types';
import { ComponentContainer } from '../ComponentContainer';
import PageUnavailableDueToIndexation from '../indexation/PageUnavailableDueToIndexation';
const wrapper = shallowRender();
wrapper.setState({
branchLikes: [mockMainBranch()],
- component: { qualifier: 'TRK', visibility: 'public' } as T.Component,
+ component: { qualifier: 'TRK', visibility: 'public' } as Component,
loading: false
});
import { shallow } from 'enzyme';
import * as React from 'react';
import { mockCurrentUser, mockLoggedInUser, mockRouter } from '../../../helpers/testMocks';
+import { CurrentUser } from '../../../types/types';
import { Landing } from '../Landing';
it.each([
mockLoggedInUser({ homepage: { type: 'ISSUES' } }),
expect.objectContaining({ pathname: '/issues' })
]
-])('should render correctly', (currentUser: T.CurrentUser, homepageUrl: string) => {
+])('should render correctly', (currentUser: CurrentUser, homepageUrl: string) => {
const router = mockRouter();
shallowRender({ router, currentUser });
expect(router.replace).toHaveBeenCalledWith(homepageUrl);
import { get, save } from '../../../helpers/storage';
import { waitAndUpdate } from '../../../helpers/testUtils';
import { EditionKey } from '../../../types/editions';
+import { LoggedInUser } from '../../../types/types';
import { StartupModal } from '../StartupModal';
jest.mock('../../../api/marketplace', () => ({
jest.mock('date-fns', () => ({ differenceInDays: jest.fn().mockReturnValue(1) }));
-const LOGGED_IN_USER: T.LoggedInUser = {
+const LOGGED_IN_USER: LoggedInUser = {
groups: [],
isLoggedIn: true,
login: 'luke',
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { createContext } from 'react';
+import { A11ySkipLink } from '../../../types/types';
export interface A11yContextShape {
- addA11ySkipLink: (link: T.A11ySkipLink) => void;
- removeA11ySkipLink: (link: T.A11ySkipLink) => void;
- links: T.A11ySkipLink[];
+ addA11ySkipLink: (link: A11ySkipLink) => void;
+ removeA11ySkipLink: (link: A11ySkipLink) => void;
+ links: A11ySkipLink[];
}
export const A11yContext = createContext<A11yContextShape>({
*/
import { sortBy } from 'lodash';
import * as React from 'react';
+import { A11ySkipLink } from '../../../types/types';
import { A11yContext } from './A11yContext';
interface State {
- links: T.A11ySkipLink[];
+ links: A11ySkipLink[];
}
export default class A11yProvider extends React.Component<{}, State> {
keys: string[] = [];
state: State = { links: [] };
- addA11ySkipLink = (link: T.A11ySkipLink) => {
+ addA11ySkipLink = (link: A11ySkipLink) => {
this.setState(prevState => {
const links = [...prevState.links];
links.push({ ...link, weight: link.weight || 0 });
});
};
- removeA11ySkipLink = (link: T.A11ySkipLink) => {
+ removeA11ySkipLink = (link: A11ySkipLink) => {
this.setState(prevState => {
const links = prevState.links.filter(l => l.key !== link.key);
return { links };
*/
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { A11ySkipLink } from '../../../types/types';
import { A11yContext } from './A11yContext';
interface Props {
}
interface InnerProps {
- addA11ySkipLink: (link: T.A11ySkipLink) => void;
- removeA11ySkipLink: (link: T.A11ySkipLink) => void;
+ addA11ySkipLink: (link: A11ySkipLink) => void;
+ removeA11ySkipLink: (link: A11ySkipLink) => void;
}
export class A11ySkipTargetInner extends React.PureComponent<Props & InnerProps> {
this.props.removeA11ySkipLink(this.getLink());
}
- getLink = (): T.A11ySkipLink => {
+ getLink = (): A11ySkipLink => {
const { anchor: key, label = translate('skip_to_content'), weight } = this.props;
return { key, label, weight };
};
import { DropdownOverlay } from '../../../components/controls/Dropdown';
import { translate } from '../../../helpers/l10n';
import { getBaseUrl } from '../../../helpers/system';
+import { SuggestionLink } from '../../../types/types';
import { SuggestionsContext } from './SuggestionsContext';
interface Props {
return <li className="menu-header">{text}</li>;
}
- renderSuggestions = ({ suggestions }: { suggestions: T.SuggestionLink[] }) => {
+ renderSuggestions = ({ suggestions }: { suggestions: SuggestionLink[] }) => {
if (suggestions.length === 0) {
return null;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { createContext } from 'react';
+import { SuggestionLink } from '../../../types/types';
interface SuggestionsContextShape {
addSuggestions: (key: string) => void;
removeSuggestions: (key: string) => void;
- suggestions: T.SuggestionLink[];
+ suggestions: SuggestionLink[];
}
export const SuggestionsContext = createContext<SuggestionsContextShape>({
import suggestionsJson from 'Docs/EmbedDocsSuggestions.json';
import * as React from 'react';
import { isSonarCloud } from '../../../helpers/system';
+import { Dict, SuggestionLink } from '../../../types/types';
import { SuggestionsContext } from './SuggestionsContext';
-type SuggestionsJson = T.Dict<T.SuggestionLink[]>;
+type SuggestionsJson = Dict<SuggestionLink[]>;
interface State {
- suggestions: T.SuggestionLink[];
+ suggestions: SuggestionLink[];
}
export default class SuggestionsProvider extends React.Component<{}, State> {
fetchSuggestions = () => {
const jsonList = suggestionsJson as SuggestionsJson;
- let suggestions: T.SuggestionLink[] = [];
+ let suggestions: SuggestionLink[] = [];
this.keys.forEach(key => {
if (jsonList[key]) {
suggestions = [...jsonList[key], ...suggestions];
import { addGlobalErrorMessage } from '../../../store/globalMessages';
import { getCurrentUser, Store } from '../../../store/rootReducer';
import { ExtensionStartMethod } from '../../../types/extension';
+import { CurrentUser, Dict, Extension as TypeExtension } from '../../../types/types';
import * as theme from '../../theme';
import getStore from '../../utils/getStore';
interface Props extends WrappedComponentProps {
- currentUser: T.CurrentUser;
- extension: T.Extension;
+ currentUser: CurrentUser;
+ extension: TypeExtension;
location: Location;
onFail: (message: string) => void;
+ options?: Dict<any>;
router: Router;
}
import * as React from 'react';
import { connect } from 'react-redux';
import { getAppState, Store } from '../../../store/rootReducer';
+import { Extension as TypeExtension } from '../../../types/types';
import NotFound from '../NotFound';
import Extension from './Extension';
interface Props {
- adminPages: T.Extension[] | undefined;
+ adminPages: TypeExtension[] | undefined;
params: { extensionKey: string; pluginKey: string };
}
import * as React from 'react';
import { connect } from 'react-redux';
import { getAppState, Store } from '../../../store/rootReducer';
+import { Extension as TypeExtension } from '../../../types/types';
import NotFound from '../NotFound';
import Extension from './Extension';
interface Props {
- globalPages: T.Extension[] | undefined;
+ globalPages: TypeExtension[] | undefined;
params: { extensionKey: string; pluginKey: string };
}
import * as React from 'react';
import { WithRouterProps } from 'react-router';
import withIndexationGuard from '../../../components/hoc/withIndexationGuard';
+import { Component } from '../../../types/types';
import { PageContext } from '../indexation/PageUnavailableDueToIndexation';
import ProjectPageExtension from './ProjectPageExtension';
export interface PortfolioPageProps extends WithRouterProps {
- component: T.Component;
+ component: Component;
}
export function PortfolioPage({ component, location }: PortfolioPageProps) {
import * as React from 'react';
import { connect } from 'react-redux';
import { addGlobalErrorMessage } from '../../../store/globalMessages';
+import { Component } from '../../../types/types';
import NotFound from '../NotFound';
import Extension from './Extension';
export interface ProjectAdminPageExtensionProps {
- component: T.Component;
+ component: Component;
location: Location;
params: { extensionKey: string; pluginKey: string };
}
*/
import * as React from 'react';
import { BranchLike } from '../../../types/branch-like';
+import { Component } from '../../../types/types';
import NotFound from '../NotFound';
import Extension from './Extension';
export interface ProjectPageExtensionProps {
branchLike?: BranchLike;
- component: T.Component;
+ component: Component;
location: { query: { id: string } };
params: {
extensionKey: string;
import * as React from 'react';
import { withAppState } from '../../../components/hoc/withAppState';
import { IndexationContextInterface, IndexationStatus } from '../../../types/indexation';
+import { AppState } from '../../../types/types';
import { IndexationContext } from './IndexationContext';
import IndexationNotificationHelper from './IndexationNotificationHelper';
interface Props {
- appState: Pick<T.AppState, 'needIssueSync'>;
+ appState: Pick<AppState, 'needIssueSync'>;
}
export class IndexationContextProvider extends React.PureComponent<
import { hasGlobalPermission, isLoggedIn } from '../../../helpers/users';
import { IndexationNotificationType } from '../../../types/indexation';
import { Permissions } from '../../../types/permissions';
+import { CurrentUser } from '../../../types/types';
import './IndexationNotification.css';
import IndexationNotificationHelper from './IndexationNotificationHelper';
import IndexationNotificationRenderer from './IndexationNotificationRenderer';
interface Props extends WithIndexationContextProps {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
}
interface State {
} from '../../../components/hoc/withIndexationContext';
import { Alert } from '../../../components/ui/Alert';
import { translate } from '../../../helpers/l10n';
+import { Component } from '../../../types/types';
interface Props extends WithIndexationContextProps {
pageContext?: PageContext;
- component?: Pick<T.Component, 'qualifier' | 'name'>;
+ component?: Pick<Component, 'qualifier' | 'name'>;
}
export enum PageContext {
import { isMainBranch } from '../../../../helpers/branch-like';
import { getComponentOverviewUrl } from '../../../../helpers/urls';
import { BranchLike } from '../../../../types/branch-like';
+import { Component } from '../../../../types/types';
interface Props {
- component: T.Component;
+ component: Component;
currentBranchLike: BranchLike | undefined;
}
import { BranchLike } from '../../../../types/branch-like';
import { ComponentQualifier } from '../../../../types/component';
import { Task, TaskStatuses, TaskWarning } from '../../../../types/tasks';
+import { Component } from '../../../../types/types';
import { rawSizes } from '../../../theme';
import RecentHistory from '../../RecentHistory';
import ComponentNavBgTaskNotif from './ComponentNavBgTaskNotif';
export interface ComponentNavProps {
branchLikes: BranchLike[];
currentBranchLike: BranchLike | undefined;
- component: T.Component;
+ component: Component;
currentTask?: Task;
currentTaskOnSameBranch?: boolean;
isInProgress?: boolean;
isPending?: boolean;
- onComponentChange: (changes: Partial<T.Component>) => void;
+ onComponentChange: (changes: Partial<Component>) => void;
onWarningDismiss: () => void;
projectBinding?: ProjectAlmBindingResponse;
projectBindingErrors?: ProjectAlmBindingConfigurationErrors;
import { hasMessage, translate } from '../../../../helpers/l10n';
import { getComponentBackgroundTaskUrl } from '../../../../helpers/urls';
import { Task, TaskStatuses } from '../../../../types/tasks';
+import { Component } from '../../../../types/types';
import ComponentNavLicenseNotif from './ComponentNavLicenseNotif';
interface Props extends Pick<WithRouterProps, 'location'> {
- component: T.Component;
+ component: Component;
currentTask?: Task;
currentTaskOnSameBranch?: boolean;
isInProgress?: boolean;
import { translate, translateWithParameters } from '../../../../helpers/l10n';
import { ComponentQualifier } from '../../../../types/component';
import { Task } from '../../../../types/tasks';
+import { AppState } from '../../../../types/types';
interface Props {
- appState: Pick<T.AppState, 'canAdmin'>;
+ appState: Pick<AppState, 'canAdmin'>;
currentTask?: Task;
}
import { Alert } from '../../../../components/ui/Alert';
import { translate } from '../../../../helpers/l10n';
import { getProjectSettingsUrl } from '../../../../helpers/urls';
+import { Component } from '../../../../types/types';
export interface ComponentNavProjectBindingErrorNotifProps {
- component: T.Component;
+ component: Component;
}
export function ComponentNavProjectBindingErrorNotif(
import { getCurrentUser, Store } from '../../../../store/rootReducer';
import { ProjectAlmBindingResponse } from '../../../../types/alm-settings';
import { BranchLike } from '../../../../types/branch-like';
+import { Component, CurrentUser } from '../../../../types/types';
import BranchLikeNavigation from './branch-like/BranchLikeNavigation';
import CurrentBranchLikeMergeInformation from './branch-like/CurrentBranchLikeMergeInformation';
import { Breadcrumb } from './Breadcrumb';
export interface HeaderProps {
branchLikes: BranchLike[];
- component: T.Component;
+ component: Component;
currentBranchLike: BranchLike | undefined;
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
projectBinding?: ProjectAlmBindingResponse;
}
import { BranchLike } from '../../../../types/branch-like';
import { ComponentQualifier } from '../../../../types/component';
import { TaskWarning } from '../../../../types/tasks';
+import { Component, CurrentUser, HomePage } from '../../../../types/types';
import ComponentNavWarnings from './ComponentNavWarnings';
import './HeaderMeta.css';
export interface HeaderMetaProps {
branchLike?: BranchLike;
- currentUser: T.CurrentUser;
- component: T.Component;
+ currentUser: CurrentUser;
+ component: Component;
onWarningDismiss: () => void;
warnings: TaskWarning[];
}
);
}
-export function getCurrentPage(component: T.Component, branchLike: BranchLike | undefined) {
- let currentPage: T.HomePage | undefined;
+export function getCurrentPage(component: Component, branchLike: BranchLike | undefined) {
+ let currentPage: HomePage | undefined;
const branch = isBranch(branchLike) && !branchLike.isMain ? branchLike.name : undefined;
import { getPortfolioUrl, getProjectQueryUrl } from '../../../../helpers/urls';
import { BranchLike, BranchParameters } from '../../../../types/branch-like';
import { ComponentQualifier, isPortfolioLike } from '../../../../types/component';
+import { AppState, Component, Extension } from '../../../../types/types';
import './Menu.css';
const SETTINGS_URLS = [
];
interface Props {
- appState: Pick<T.AppState, 'branchesEnabled'>;
+ appState: Pick<AppState, 'branchesEnabled'>;
branchLike: BranchLike | undefined;
branchLikes: BranchLike[] | undefined;
- component: T.Component;
+ component: Component;
isInProgress?: boolean;
isPending?: boolean;
onToggleProjectInfo: () => void;
);
};
- renderExtension = ({ key, name }: T.Extension, isAdmin: boolean, baseQuery: Query) => {
+ renderExtension = ({ key, name }: Extension, isAdmin: boolean, baseQuery: Query) => {
const pathname = isAdmin ? `/project/admin/extension/${key}` : `/project/extension/${key}`;
const query = { ...baseQuery, qualifier: this.props.component.qualifier };
return (
import { withAppState } from '../../../../../components/hoc/withAppState';
import { ProjectAlmBindingResponse } from '../../../../../types/alm-settings';
import { BranchLike } from '../../../../../types/branch-like';
+import { AppState, Component } from '../../../../../types/types';
import './BranchLikeNavigation.css';
import CurrentBranchLike from './CurrentBranchLike';
import Menu from './Menu';
export interface BranchLikeNavigationProps {
- appState: Pick<T.AppState, 'branchesEnabled'>;
+ appState: Pick<AppState, 'branchesEnabled'>;
branchLikes: BranchLike[];
- component: T.Component;
+ component: Component;
currentBranchLike: BranchLike;
projectBinding?: ProjectAlmBindingResponse;
}
import { AlmKeys, ProjectAlmBindingResponse } from '../../../../../types/alm-settings';
import { BranchLike } from '../../../../../types/branch-like';
import { ComponentQualifier } from '../../../../../types/component';
+import { Component } from '../../../../../types/types';
import { colors } from '../../../../theme';
export interface CurrentBranchLikeProps {
branchesEnabled: boolean;
- component: T.Component;
+ component: Component;
currentBranchLike: BranchLike;
hasManyBranches: boolean;
projectBinding?: ProjectAlmBindingResponse;
import { getBranchLikeUrl } from '../../../../../helpers/urls';
import { BranchLike, BranchLikeTree } from '../../../../../types/branch-like';
import { ComponentQualifier } from '../../../../../types/component';
+import { Component } from '../../../../../types/types';
import MenuItemList from './MenuItemList';
interface Props {
branchLikes: BranchLike[];
canAdminComponent?: boolean;
- component: T.Component;
+ component: Component;
currentBranchLike: BranchLike;
onClose: () => void;
router: Pick<Router, 'push'>;
import { getBranchLikeDisplayName, isMainBranch } from '../../../../../helpers/branch-like';
import { translate } from '../../../../../helpers/l10n';
import { BranchLike } from '../../../../../types/branch-like';
+import { Component } from '../../../../../types/types';
export interface MenuItemProps {
branchLike: BranchLike;
- component: T.Component;
+ component: Component;
indent?: boolean;
onSelect: (branchLike: BranchLike) => void;
selected: boolean;
import { scrollToElement } from '../../../../../helpers/scrolling';
import { isDefined } from '../../../../../helpers/types';
import { BranchLike, BranchLikeTree } from '../../../../../types/branch-like';
+import { Component } from '../../../../../types/types';
import MenuItem from './MenuItem';
export interface MenuItemListProps {
branchLikeTree: BranchLikeTree;
- component: T.Component;
+ component: Component;
hasResults: boolean;
onSelect: (branchLike: BranchLike) => void;
selectedBranchLike: BranchLike | undefined;
import { BranchLike } from '../../../../../types/branch-like';
import { ComponentQualifier } from '../../../../../types/component';
import { MetricKey } from '../../../../../types/metrics';
+import { Component, CurrentUser, Dict, Measure, Metric } from '../../../../../types/types';
import ProjectBadges from './badges/ProjectBadges';
import InfoDrawerPage from './InfoDrawerPage';
import ProjectNotifications from './notifications/ProjectNotifications';
interface Props {
branchLike?: BranchLike;
- component: T.Component;
- currentUser: T.CurrentUser;
+ component: Component;
+ currentUser: CurrentUser;
fetchMetrics: () => void;
onComponentChange: (changes: {}) => void;
- metrics: T.Dict<T.Metric>;
+ metrics: Dict<Metric>;
}
interface State {
- measures?: T.Measure[];
+ measures?: Measure[];
page: ProjectInformationPages;
}
import PrivacyBadgeContainer from '../../../../../components/common/PrivacyBadgeContainer';
import { translate } from '../../../../../helpers/l10n';
import { ComponentQualifier } from '../../../../../types/component';
+import { Component, Measure } from '../../../../../types/types';
import DrawerLink from './DrawerLink';
import MetaKey from './meta/MetaKey';
import MetaLinks from './meta/MetaLinks';
export interface ProjectInformationRendererProps {
canConfigureNotifications: boolean;
canUseBadges: boolean;
- component: T.Component;
- measures?: T.Measure[];
+ component: Component;
+ measures?: Measure[];
onComponentChange: (changes: {}) => void;
onPageChange: (page: ProjectInformationPages) => void;
}
import { fetchWebApi } from '../../../../../../api/web-api';
import SelectLegacy from '../../../../../../components/controls/SelectLegacy';
import { getLocalizedMetricName, translate } from '../../../../../../helpers/l10n';
+import { Dict, Metric } from '../../../../../../types/types';
import { BadgeFormats, BadgeOptions, BadgeType } from './utils';
interface Props {
className?: string;
- metrics: T.Dict<T.Metric>;
+ metrics: Dict<Metric>;
options: BadgeOptions;
type: BadgeType;
updateOptions: (options: Partial<BadgeOptions>) => void;
import { translate } from '../../../../../../helpers/l10n';
import { BranchLike } from '../../../../../../types/branch-like';
import { MetricKey } from '../../../../../../types/metrics';
+import { Component, Dict, Metric } from '../../../../../../types/types';
import BadgeButton from './BadgeButton';
import BadgeParams from './BadgeParams';
import './styles.css';
interface Props {
branchLike?: BranchLike;
- metrics: T.Dict<T.Metric>;
- component: T.Component;
+ metrics: Dict<Metric>;
+ component: Component;
}
interface State {
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { Metric } from '../../../../../../../types/types';
import BadgeParams from '../BadgeParams';
import { BadgeType } from '../utils';
}));
const METRICS = {
- alert_status: { key: 'alert_status', name: 'Quality Gate' } as T.Metric,
- coverage: { key: 'coverage', name: 'Coverage' } as T.Metric
+ alert_status: { key: 'alert_status', name: 'Quality Gate' } as Metric,
+ coverage: { key: 'coverage', name: 'Coverage' } as Metric
};
it('should display measure badge params', () => {
import { ClearButton } from '../../../../../../components/controls/buttons';
import ProjectLinkIcon from '../../../../../../components/icons/ProjectLinkIcon';
import { getLinkName } from '../../../../../../helpers/projectLinks';
+import { ProjectLink } from '../../../../../../types/types';
import isValidUri from '../../../../../utils/isValidUri';
interface Props {
iconOnly?: boolean;
- link: T.ProjectLink;
+ link: ProjectLink;
}
interface State {
import { getProjectLinks } from '../../../../../../api/projectLinks';
import { translate } from '../../../../../../helpers/l10n';
import { orderLinks } from '../../../../../../helpers/projectLinks';
+import { LightComponent, ProjectLink } from '../../../../../../types/types';
import MetaLink from './MetaLink';
interface Props {
- component: T.LightComponent;
+ component: LightComponent;
}
interface State {
- links?: T.ProjectLink[];
+ links?: ProjectLink[];
}
export default class MetaLinks extends React.PureComponent<Props, State> {
import { translate, translateWithParameters } from '../../../../../../helpers/l10n';
import { getQualityProfileUrl } from '../../../../../../helpers/urls';
import { getLanguages, Store } from '../../../../../../store/rootReducer';
+import { ComponentQualityProfile, Dict, Languages } from '../../../../../../types/types';
interface StateProps {
- languages: T.Languages;
+ languages: Languages;
}
interface OwnProps {
headerClassName?: string;
- profiles: T.ComponentQualityProfile[];
+ profiles: ComponentQualityProfile[];
}
interface State {
- deprecatedByKey: T.Dict<number>;
+ deprecatedByKey: Dict<number>;
}
export class MetaQualityProfiles extends React.PureComponent<StateProps & OwnProps, State> {
Promise.all(requests).then(
responses => {
if (this.mounted) {
- const deprecatedByKey: T.Dict<number> = {};
+ const deprecatedByKey: Dict<number> = {};
responses.forEach((count, i) => {
const profileKey = existingProfiles[i].key;
deprecatedByKey[profileKey] = count;
return count || 0;
}
- renderProfile(profile: T.ComponentQualityProfile) {
+ renderProfile(profile: ComponentQualityProfile) {
const languageFromStore = this.props.languages[profile.language];
const languageName = languageFromStore ? languageFromStore.name : profile.language;
import { formatMeasure, localizeMetric } from '../../../../../../helpers/measures';
import { ComponentQualifier } from '../../../../../../types/component';
import { MetricKey } from '../../../../../../types/metrics';
+import { Component, Measure } from '../../../../../../types/types';
export interface MetaSizeProps {
- component: T.Component;
- measures: T.Measure[];
+ component: Component;
+ measures: Measure[];
}
export default function MetaSize({ component, measures }: MetaSizeProps) {
import { PopupPlacement } from '../../../../../../components/ui/popups';
import { translate } from '../../../../../../helpers/l10n';
import { ComponentQualifier } from '../../../../../../types/component';
+import { Component } from '../../../../../../types/types';
import MetaTagsSelector from './MetaTagsSelector';
interface Props {
- component: T.Component;
+ component: Component;
onComponentChange: (changes: {}) => void;
}
import { Alert } from '../../../../../../components/ui/Alert';
import DeferredSpinner from '../../../../../../components/ui/DeferredSpinner';
import { translate } from '../../../../../../helpers/l10n';
+import { Component } from '../../../../../../types/types';
interface Props {
- component: T.Component;
+ component: Component;
}
export function ProjectNotifications(props: WithNotificationsProps & Props) {
import { connect } from 'react-redux';
import NavBar from '../../../../components/ui/NavBar';
import { getAppState, getCurrentUser, Store } from '../../../../store/rootReducer';
+import { AppState, CurrentUser } from '../../../../types/types';
import { rawSizes } from '../../../theme';
import EmbedDocsPopupHelper from '../../embed-docs-modal/EmbedDocsPopupHelper';
import Search from '../../search/Search';
import GlobalNavUser from './GlobalNavUser';
export interface GlobalNavProps {
- appState: Pick<T.AppState, 'canAdmin' | 'globalPages' | 'qualifiers'>;
- currentUser: T.CurrentUser;
+ appState: Pick<AppState, 'canAdmin' | 'globalPages' | 'qualifiers'>;
+ currentUser: CurrentUser;
location: { pathname: string };
}
import { translate } from '../../../../helpers/l10n';
import { getQualityGatesUrl } from '../../../../helpers/urls';
import { ComponentQualifier } from '../../../../types/component';
+import { AppState, CurrentUser, Extension } from '../../../../types/types';
interface Props {
- appState: Pick<T.AppState, 'canAdmin' | 'globalPages' | 'qualifiers'>;
- currentUser: T.CurrentUser;
+ appState: Pick<AppState, 'canAdmin' | 'globalPages' | 'qualifiers'>;
+ currentUser: CurrentUser;
location: { pathname: string };
}
);
}
- renderGlobalPageLink = ({ key, name }: T.Extension) => {
+ renderGlobalPageLink = ({ key, name }: Extension) => {
return (
<li key={key}>
<Link to={`/extension/${key}`}>{name}</Link>
import { translate } from '../../../../helpers/l10n';
import { getBaseUrl } from '../../../../helpers/system';
import { isLoggedIn } from '../../../../helpers/users';
+import { CurrentUser, LoggedInUser } from '../../../../types/types';
import { rawSizes } from '../../../theme';
interface Props {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
router: Pick<Router, 'push'>;
}
};
renderAuthenticated() {
- const currentUser = this.props.currentUser as T.LoggedInUser;
+ const currentUser = this.props.currentUser as LoggedInUser;
return (
<Dropdown
className="js-user-authenticated"
import { Alert } from '../../../../components/ui/Alert';
import { translate } from '../../../../helpers/l10n';
import { PendingPluginResult } from '../../../../types/plugins';
+import { SysStatus } from '../../../../types/types';
interface Props {
fetchSystemStatus: () => void;
pending: PendingPluginResult;
refreshPending: () => void;
- systemStatus: T.SysStatus;
+ systemStatus: SysStatus;
}
export default class PendingPluginsActionNotif extends React.PureComponent<Props> {
import { getBaseUrl } from '../../../../helpers/system';
import { AdminPageExtension } from '../../../../types/extension';
import { PendingPluginResult } from '../../../../types/plugins';
+import { Extension, SysStatus } from '../../../../types/types';
import { rawSizes } from '../../../theme';
import PendingPluginsActionNotif from './PendingPluginsActionNotif';
import SystemRestartNotif from './SystemRestartNotif';
interface Props {
- extensions: T.Extension[];
+ extensions: Extension[];
fetchPendingPlugins: () => void;
fetchSystemStatus: () => void;
location: {};
pendingPlugins: PendingPluginResult;
- systemStatus: T.SysStatus;
+ systemStatus: SysStatus;
}
export default class SettingsNav extends React.PureComponent<Props> {
return this.isSomethingActive(urls);
}
- renderExtension = ({ key, name }: T.Extension) => {
+ renderExtension = ({ key, name }: Extension) => {
return (
<li key={key}>
<Link activeClassName="active" to={`/admin/extension/${key}`}>
import { getBaseUrl } from '../../../helpers/system';
import { isLoggedIn } from '../../../helpers/users';
import { setSonarlintAd } from '../../../store/users';
+import { CurrentUser } from '../../../types/types';
import './PromotionNotification.css';
export interface PromotionNotificationProps {
setSonarlintAd: () => void;
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
}
export function PromotionNotification(props: PromotionNotificationProps) {
import { scrollToElement } from '../../../helpers/scrolling';
import { getComponentOverviewUrl } from '../../../helpers/urls';
import { ComponentQualifier } from '../../../types/component';
+import { CurrentUser, Dict } from '../../../types/types';
import RecentHistory from '../RecentHistory';
import './Search.css';
import { ComponentResult, More, Results, sortQualifiers } from './utils';
const SearchResult = lazyLoadComponent(() => import('./SearchResult'));
interface OwnProps {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
}
type Props = OwnProps & WithRouterProps;
loadingMore?: string;
more: More;
open: boolean;
- projects: T.Dict<{ name: string }>;
+ projects: Dict<{ name: string }>;
query: string;
results: Results;
selected?: string;
export class Search extends React.PureComponent<Props, State> {
input?: HTMLInputElement | null;
node?: HTMLElement | null;
- nodes: T.Dict<HTMLElement>;
+ nodes: Dict<HTMLElement>;
mounted = false;
constructor(props: Props) {
import FavoriteIcon from '../../../components/icons/FavoriteIcon';
import QualifierIcon from '../../../components/icons/QualifierIcon';
import { getComponentOverviewUrl } from '../../../helpers/urls';
+import { Dict } from '../../../types/types';
import { ComponentResult } from './utils';
interface Props {
innerRef: (componentKey: string, node: HTMLElement | null) => void;
onClose: () => void;
onSelect: (componentKey: string) => void;
- projects: T.Dict<{ name: string }>;
+ projects: Dict<{ name: string }>;
selected: boolean;
}
import { hasGlobalPermission, isLoggedIn } from '../../../helpers/users';
import { Permissions } from '../../../types/permissions';
import { SystemUpgrade } from '../../../types/system';
+import { AppState, CurrentUser, Dict } from '../../../types/types';
import './UpdateNotification.css';
const MONTH_BEFOR_PREVIOUS_LTS_NOTIFICATION = 6;
type GroupedSystemUpdate = {
- [x: string]: T.Dict<SystemUpgrade[]>;
+ [x: string]: Dict<SystemUpgrade[]>;
};
-const MAP_VARIANT:
T.Dict<AlertVariant> = {
+const MAP_VARIANT: Dict<AlertVariant> = {
[UpdateUseCase.NewMinorVersion]: 'info',
[UpdateUseCase.NewPatch]: 'warning',
[UpdateUseCase.PreLTS]: 'warning',
interface Props {
dismissable: boolean;
- appState: Pick<T.AppState, 'version'>;
- currentUser: T.CurrentUser;
+ appState: Pick<AppState, 'version'>;
+ currentUser: CurrentUser;
}
interface State {
import { loadL10nBundle } from '../helpers/l10n';
import { parseJSON, request } from '../helpers/request';
import { getBaseUrl, getSystemStatus } from '../helpers/system';
+import { AppState } from '../types/types';
import './styles/sonar.ts';
installWebAnalyticsHandler();
} else {
// login, maintenance or setup pages
- const appStatePromise: Promise<T.AppState | undefined> = new Promise(resolve => {
+ const appStatePromise: Promise<AppState | undefined> = new Promise(resolve => {
loadAppState()
.then(data => {
resolve(data);
import rootReducer, { Store as State } from '../../store/rootReducer';
import { receiveCurrentUser } from '../../store/users';
import configureStore from '../../store/utils/configureStore';
+import { AppState, CurrentUser } from '../../types/types';
let store: Store<State, any>;
-const createStore = (currentUser?: T.CurrentUser, appState?: T.AppState) => {
+const createStore = (currentUser?: CurrentUser, appState?: AppState) => {
store = configureStore(rootReducer);
if (currentUser) {
store.dispatch(receiveCurrentUser(currentUser));
return store;
};
-export default (currentUser?: T.CurrentUser, appState?: T.AppState) =>
+export default (currentUser?: CurrentUser, appState?: AppState) =>
store ? store : createStore(currentUser, appState);
import withIndexationGuard from '../../components/hoc/withIndexationGuard';
import { lazyLoadComponent } from '../../components/lazyLoadComponent';
import getHistory from '../../helpers/getHistory';
+import { AppState, CurrentUser } from '../../types/types';
import App from '../components/App';
import GlobalContainer from '../components/GlobalContainer';
import { PageContext } from '../components/indexation/PageUnavailableDueToIndexation';
export default function startReactApp(
lang: string,
- currentUser?: T.CurrentUser,
- appState?: T.AppState
+ currentUser?: CurrentUser,
+ appState?: AppState
) {
attachToGlobal();
import { withCurrentUser } from '../../../components/hoc/withCurrentUser';
import handleRequiredAuthentication from '../../../helpers/handleRequiredAuthentication';
import { translate } from '../../../helpers/l10n';
+import { CurrentUser, LoggedInUser } from '../../../types/types';
import '../account.css';
import Nav from './Nav';
import UserCard from './UserCard';
interface Props {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
}
export class Account extends React.PureComponent<Props> {
<A11ySkipTarget anchor="account_main" />
<header className="account-header">
<div className="account-container clearfix">
- <UserCard user={currentUser as T.LoggedInUser} />
+ <UserCard user={currentUser as LoggedInUser} />
<Nav />
</div>
</header>
import ResetPasswordForm from '../../../components/common/ResetPasswordForm';
import { translate } from '../../../helpers/l10n';
import { getCurrentUser, Store } from '../../../store/rootReducer';
+import { LoggedInUser } from '../../../types/types';
import Tokens from './Tokens';
export interface SecurityProps {
- user: T.LoggedInUser;
+ user: LoggedInUser;
}
export function Security({ user }: SecurityProps) {
}
const mapStateToProps = (state: Store) => ({
- user: getCurrentUser(state) as T.LoggedInUser
+ user: getCurrentUser(state) as LoggedInUser
});
export default connect(mapStateToProps)(Security);
*/
import * as React from 'react';
import Avatar from '../../../components/ui/Avatar';
+import { LoggedInUser } from '../../../types/types';
interface Props {
- user: T.LoggedInUser;
+ user: LoggedInUser;
}
export default function UserCard({ user }: Props) {
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
import { isSonarCloud } from '../../../helpers/system';
+import { Notification } from '../../../types/types';
import NotificationsList from './NotificationsList';
import SonarCloudNotifications from './SonarCloudNotifications';
interface Props {
- addNotification: (n: T.Notification) => void;
+ addNotification: (n: Notification) => void;
channels: string[];
- notifications: T.Notification[];
- removeNotification: (n: T.Notification) => void;
+ notifications: Notification[];
+ removeNotification: (n: Notification) => void;
types: string[];
}
import * as React from 'react';
import Checkbox from '../../../components/controls/Checkbox';
import { hasMessage, translate } from '../../../helpers/l10n';
+import { Notification } from '../../../types/types';
interface Props {
- onAdd: (n: T.Notification) => void;
- onRemove: (n: T.Notification) => void;
+ onAdd: (n: Notification) => void;
+ onRemove: (n: Notification) => void;
channels: string[];
checkboxId: (type: string, channel: string) => string;
project?: boolean;
types: string[];
- notifications: T.Notification[];
+ notifications: Notification[];
}
export default class NotificationsList extends React.PureComponent<Props> {
import SimpleModal from '../../../components/controls/SimpleModal';
import { KeyboardCodes } from '../../../helpers/keycodes';
import { translate } from '../../../helpers/l10n';
+import { NotificationProject } from '../../../types/types';
interface Props {
- addedProjects: T.NotificationProject[];
+ addedProjects: NotificationProject[];
closeModal: VoidFunction;
- onSubmit: (project: T.NotificationProject) => void;
+ onSubmit: (project: NotificationProject) => void;
}
interface State {
- highlighted?: T.NotificationProject;
+ highlighted?: NotificationProject;
loading?: boolean;
query?: string;
open?: boolean;
- selectedProject?: T.NotificationProject;
- suggestions?: T.NotificationProject[];
+ selectedProject?: NotificationProject;
+ suggestions?: NotificationProject[];
}
export default class ProjectModal extends React.PureComponent<Props, State> {
);
};
- handleSelect = (selectedProject: T.NotificationProject) => {
+ handleSelect = (selectedProject: NotificationProject) => {
this.setState({
open: false,
query: selectedProject.projectName,
import * as React from 'react';
import BoxedGroupAccordion from '../../../components/controls/BoxedGroupAccordion';
import { translate } from '../../../helpers/l10n';
+import { Notification, NotificationProject } from '../../../types/types';
import NotificationsList from './NotificationsList';
interface Props {
- addNotification: (n: T.Notification) => void;
+ addNotification: (n: Notification) => void;
channels: string[];
collapsed: boolean;
- notifications: T.Notification[];
- project: T.NotificationProject;
- removeNotification: (n: T.Notification) => void;
+ notifications: Notification[];
+ project: NotificationProject;
+ removeNotification: (n: Notification) => void;
types: string[];
}
import { Button } from '../../../components/controls/buttons';
import SearchBox from '../../../components/controls/SearchBox';
import { translate } from '../../../helpers/l10n';
+import { Notification, NotificationProject } from '../../../types/types';
import ProjectModal from './ProjectModal';
import ProjectNotifications from './ProjectNotifications';
export interface Props {
- addNotification: (n: T.Notification) => void;
+ addNotification: (n: Notification) => void;
channels: string[];
- notifications: T.Notification[];
- removeNotification: (n: T.Notification) => void;
+ notifications: Notification[];
+ removeNotification: (n: Notification) => void;
types: string[];
}
const THRESHOLD_COLLAPSED = 3;
interface State {
- addedProjects: T.NotificationProject[];
+ addedProjects: NotificationProject[];
search: string;
showModal: boolean;
}
function isNotificationProject(project: {
project?: string;
projectName?: string;
-}): project is T.NotificationProject {
+}): project is NotificationProject {
return project.project !== undefined && project.projectName !== undefined;
}
showModal: false
};
- filterSearch = (project: T.NotificationProject, search: string) => {
+ filterSearch = (project: NotificationProject, search: string) => {
return project.projectName && project.projectName.toLowerCase().includes(search);
};
- handleAddProject = (project: T.NotificationProject) => {
+ handleAddProject = (project: NotificationProject) => {
this.setState(state => {
return {
addedProjects: [...state.addedProjects, project]
this.setState({ search: search.toLowerCase() });
};
- handleSubmit = (selectedProject: T.NotificationProject) => {
+ handleSubmit = (selectedProject: NotificationProject) => {
if (selectedProject) {
this.handleAddProject(selectedProject);
}
this.setState({ showModal: true });
};
- removeNotification = (removed: T.Notification, allProjects: T.NotificationProject[]) => {
+ removeNotification = (removed: Notification, allProjects: NotificationProject[]) => {
const projectToRemove = allProjects.find(p => p.project === removed.project);
if (projectToRemove) {
this.handleAddProject(projectToRemove);
const projects = uniqBy(notifications, project => project.project).filter(
isNotificationProject
- ) as T.NotificationProject[];
+ ) as NotificationProject[];
const notificationsByProject = groupBy(notifications, n => n.project);
const allProjects = uniqBy([...addedProjects, ...projects], project => project.project);
const filteredProjects = sortBy(allProjects, 'projectName').filter(p =>
import { translate } from '../../../helpers/l10n';
import { getCurrentUserSetting, Store } from '../../../store/rootReducer';
import { setCurrentUserSetting } from '../../../store/users';
+import { CurrentUserSetting } from '../../../types/types';
interface Props {
notificationsOptOut?: boolean;
- setCurrentUserSetting: (setting: T.CurrentUserSetting) => void;
+ setCurrentUserSetting: (setting: CurrentUserSetting) => void;
}
export class SonarCloudNotifications extends React.PureComponent<Props> {
import HelpTooltip from '../../../components/controls/HelpTooltip';
import { whenLoggedIn } from '../../../components/hoc/whenLoggedIn';
import { translate } from '../../../helpers/l10n';
+import { LoggedInUser } from '../../../types/types';
import UserExternalIdentity from './UserExternalIdentity';
export interface ProfileProps {
- currentUser: T.LoggedInUser;
+ currentUser: LoggedInUser;
}
export function Profile({ currentUser }: ProfileProps) {
import { colors } from '../../../app/theme';
import { getTextColor } from '../../../helpers/colors';
import { getBaseUrl } from '../../../helpers/system';
+import { IdentityProvider, LoggedInUser } from '../../../types/types';
export interface UserExternalIdentityProps {
- user: T.LoggedInUser;
+ user: LoggedInUser;
}
interface State {
- identityProvider?: T.IdentityProvider;
+ identityProvider?: IdentityProvider;
loading: boolean;
}
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { orderLinks } from '../../../helpers/projectLinks';
import { getProjectUrl } from '../../../helpers/urls';
+import { MyProject, ProjectLink } from '../../../types/types';
interface Props {
- project: T.MyProject;
+ project: MyProject;
}
export default function ProjectCard({ project }: Props) {
const { links } = project;
- const orderedLinks: T.ProjectLink[] = orderLinks(
+ const orderedLinks: ProjectLink[] = orderLinks(
links.map((link, i) => {
const { href, name, type } = link;
return {
import * as React from 'react';
import ListFooter from '../../../components/controls/ListFooter';
import { translate } from '../../../helpers/l10n';
+import { MyProject } from '../../../types/types';
import ProjectCard from './ProjectCard';
interface Props {
loading: boolean;
loadMore: () => void;
- projects: T.MyProject[];
+ projects: MyProject[];
total?: number;
}
import { Helmet } from 'react-helmet-async';
import { getMyProjects } from '../../../api/components';
import { translate } from '../../../helpers/l10n';
+import { MyProject } from '../../../types/types';
import Projects from './Projects';
interface State {
loading: boolean;
page: number;
- projects?: T.MyProject[];
+ projects?: MyProject[];
total?: number;
}
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { MyProject } from '../../../../types/types';
import ProjectCard from '../ProjectCard';
it('should render key and name', () => {
expect(wrapper.find('MetaLink').length).toBe(1);
});
-function shallowRender(project: Partial<T.MyProject> = {}) {
+function shallowRender(project: Partial<MyProject> = {}) {
return shallow(<ProjectCard project={{ key: 'key', links: [], name: 'name', ...project }} />);
}
import { translate } from '../../../helpers/l10n';
import { parseAsDate } from '../../../helpers/query';
import { Task, TaskStatuses } from '../../../types/tasks';
+import { Component } from '../../../types/types';
import '../background-tasks.css';
import { CURRENTS, DEBOUNCE_DELAY, DEFAULT_FILTERS } from '../constants';
import { mapFiltersToParameters, Query, updateTask } from '../utils';
import Tasks from './Tasks';
interface Props {
- component?: Pick<T.Component, 'key'> & { id: string }; // id should be removed when api/ce/activity accept a component key instead of an id
+ component?: Pick<Component, 'key'> & { id: string }; // id should be removed when api/ce/activity accept a component key instead of an id
location: Location;
router: Pick<Router, 'push'>;
}
import HelpTooltip from '../../../components/controls/HelpTooltip';
import { translate } from '../../../helpers/l10n';
import { formatMeasure } from '../../../helpers/measures';
+import { Component } from '../../../types/types';
// Do not display the pending time for values smaller than this threshold (in ms)
const MIN_PENDING_TIME_THRESHOLD = 1000;
export interface Props {
className?: string;
- component?: Pick<T.Component, 'key'>;
+ component?: Pick<Component, 'key'>;
pendingCount?: number;
pendingTime?: number;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { Component } from '../../../types/types';
import StatPendingCount from './StatPendingCount';
import StatPendingTime from './StatPendingTime';
import StatStillFailing from './StatStillFailing';
export interface Props {
- component?: Pick<T.Component, 'key'>;
+ component?: Pick<Component, 'key'>;
failingCount?: number;
onCancelAllPending: () => void;
onShowFailing: () => void;
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+import { ComponentMeasure } from '../../../types/types';
import { addComponent, addComponentChildren, getComponent, getComponentChildren } from '../bucket';
-const component: T.ComponentMeasure = { key: 'frodo', name: 'frodo', qualifier: 'frodo' };
+const component: ComponentMeasure = { key: 'frodo', name: 'frodo', qualifier: 'frodo' };
const componentKey: string = 'foo';
-const childrenA: T.ComponentMeasure[] = [
+const childrenA: ComponentMeasure[] = [
{ key: 'foo', name: 'foo', qualifier: 'foo' },
{ key: 'bar', name: 'bar', qualifier: 'bar' }
];
-const childrenB: T.ComponentMeasure[] = [
+const childrenB: ComponentMeasure[] = [
{ key: 'bart', name: 'bart', qualifier: 'bart' },
{ key: 'simpson', name: 'simpson', qualifier: 'simpson' }
];
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-let bucket: T.Dict<T.ComponentMeasure> = {};
-let childrenBucket: T.Dict<{
- children: T.ComponentMeasure[];
+
+import { Breadcrumb, ComponentMeasure, Dict } from '../../types/types';
+
+let bucket: Dict<ComponentMeasure> = {};
+let childrenBucket: Dict<{
+ children: ComponentMeasure[];
page: number;
total: number;
}> = {};
-let breadcrumbsBucket: T.Dict<T.Breadcrumb[]> = {};
+let breadcrumbsBucket: Dict<Breadcrumb[]> = {};
-export function addComponent(component: T.ComponentMeasure): void {
+export function addComponent(component: ComponentMeasure): void {
bucket[component.key] = component;
}
-export function getComponent(componentKey: string): T.ComponentMeasure {
+export function getComponent(componentKey: string): ComponentMeasure {
return bucket[componentKey];
}
export function addComponentChildren(
componentKey: string,
- children: T.ComponentMeasure[],
+ children: ComponentMeasure[],
total: number,
page: number
): void {
export function getComponentChildren(
componentKey: string
): {
- children: T.ComponentMeasure[];
+ children: ComponentMeasure[];
page: number;
total: number;
} {
return childrenBucket[componentKey];
}
-export function addComponentBreadcrumbs(componentKey: string, breadcrumbs: T.Breadcrumb[]): void {
+export function addComponentBreadcrumbs(componentKey: string, breadcrumbs: Breadcrumb[]): void {
breadcrumbsBucket[componentKey] = breadcrumbs;
}
-export function getComponentBreadcrumbs(componentKey: string): T.Breadcrumb[] {
+export function getComponentBreadcrumbs(componentKey: string): Breadcrumb[] {
return breadcrumbsBucket[componentKey];
}
*/
import * as React from 'react';
import { BranchLike } from '../../../types/branch-like';
+import { Breadcrumb, ComponentMeasure } from '../../../types/types';
import ComponentName from './ComponentName';
interface Props {
branchLike?: BranchLike;
- breadcrumbs: T.Breadcrumb[];
- rootComponent: T.ComponentMeasure;
+ breadcrumbs: Breadcrumb[];
+ rootComponent: ComponentMeasure;
}
export default function Breadcrumbs({ branchLike, breadcrumbs, rootComponent }: Props) {
import { getMetrics } from '../../../store/rootReducer';
import { BranchLike } from '../../../types/branch-like';
import { isPortfolioLike } from '../../../types/component';
+import { Breadcrumb, Component, ComponentMeasure, Dict, Issue, Metric } from '../../../types/types';
import { addComponent, addComponentBreadcrumbs, clearBucket } from '../bucket';
import '../code.css';
import {
import SourceViewerWrapper from './SourceViewerWrapper';
interface StateToProps {
- metrics: T.Dict<T.Metric>;
+ metrics: Dict<Metric>;
}
interface DispatchToProps {
interface OwnProps {
branchLike?: BranchLike;
- component: T.Component;
+ component: Component;
location: Pick<Location, 'query'>;
router: Pick<InjectedRouter, 'push'>;
}
type Props = StateToProps & DispatchToProps & OwnProps;
interface State {
- baseComponent?: T.ComponentMeasure;
- breadcrumbs: T.Breadcrumb[];
- components?: T.ComponentMeasure[];
- highlighted?: T.ComponentMeasure;
+ baseComponent?: ComponentMeasure;
+ breadcrumbs: Breadcrumb[];
+ components?: ComponentMeasure[];
+ highlighted?: ComponentMeasure;
loading: boolean;
page: number;
- searchResults?: T.ComponentMeasure[];
- sourceViewer?: T.ComponentMeasure;
+ searchResults?: ComponentMeasure[];
+ sourceViewer?: ComponentMeasure;
total: number;
newCodeSelected: boolean;
}
}
};
- handleHighlight = (highlighted: T.ComponentMeasure) => {
+ handleHighlight = (highlighted: ComponentMeasure) => {
this.setState({ highlighted });
};
- handleIssueChange = (_: T.Issue) => {
+ handleIssueChange = (_: Issue) => {
this.refreshBranchStatus();
};
this.setState({ searchResults: undefined });
};
- handleSearchResults = (searchResults: T.ComponentMeasure[] = []) => {
+ handleSearchResults = (searchResults: ComponentMeasure[] = []) => {
this.setState({ searchResults });
};
- handleSelect = (component: T.ComponentMeasure) => {
+ handleSelect = (component: ComponentMeasure) => {
const { branchLike, component: rootComponent } = this.props;
if (component.refKey) {
import { BranchLike } from '../../../types/branch-like';
import { ComponentQualifier } from '../../../types/component';
import { MetricType } from '../../../types/metrics';
+import { ComponentMeasure as TypeComponentMeasure, Metric } from '../../../types/types';
import ComponentMeasure from './ComponentMeasure';
import ComponentName from './ComponentName';
import ComponentPin from './ComponentPin';
branchLike?: BranchLike;
canBePinned?: boolean;
canBrowse?: boolean;
- component: T.ComponentMeasure;
+ component: TypeComponentMeasure;
hasBaseComponent: boolean;
isBaseComponent?: boolean;
- metrics: T.Metric[];
- previous?: T.ComponentMeasure;
- rootComponent: T.ComponentMeasure;
+ metrics: Metric[];
+ previous?: TypeComponentMeasure;
+ rootComponent: TypeComponentMeasure;
selected?: boolean;
}
import Measure from '../../../components/measure/Measure';
import { getLeakValue } from '../../../components/measure/utils';
import { isDiffMetric } from '../../../helpers/measures';
+import { ComponentMeasure as TypeComponentMeasure, Metric } from '../../../types/types';
interface Props {
- component: T.ComponentMeasure;
- metric: T.Metric;
+ component: TypeComponentMeasure;
+ metric: Metric;
}
export default class ComponentMeasure extends React.PureComponent<Props> {
isPortfolioLike,
isProject
} from '../../../types/component';
+import { ComponentMeasure } from '../../../types/types';
-export function getTooltip(component: T.ComponentMeasure) {
+export function getTooltip(component: ComponentMeasure) {
const isFile = component.qualifier === 'FIL' || component.qualifier === 'UTS';
if (isFile && component.path) {
export interface Props {
branchLike?: BranchLike;
canBrowse?: boolean;
- component: T.ComponentMeasure;
- previous?: T.ComponentMeasure;
- rootComponent: T.ComponentMeasure;
+ component: ComponentMeasure;
+ previous?: ComponentMeasure;
+ rootComponent: ComponentMeasure;
unclickable?: boolean;
}
import { WorkspaceContextShape } from '../../../components/workspace/context';
import { translate } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
+import { ComponentMeasure } from '../../../types/types';
interface Props {
branchLike?: BranchLike;
- component: T.ComponentMeasure;
+ component: ComponentMeasure;
openComponent: WorkspaceContextShape['openComponent'];
}
import withKeyboardNavigation from '../../../components/hoc/withKeyboardNavigation';
import { getComponentMeasureUniqueKey } from '../../../helpers/component';
import { BranchLike } from '../../../types/branch-like';
+import { ComponentMeasure, Metric } from '../../../types/types';
import Component from './Component';
import ComponentsEmpty from './ComponentsEmpty';
import ComponentsHeader from './ComponentsHeader';
interface Props {
- baseComponent?: T.ComponentMeasure;
+ baseComponent?: ComponentMeasure;
branchLike?: BranchLike;
- components: T.ComponentMeasure[];
- metrics: T.Metric[];
- rootComponent: T.ComponentMeasure;
- selected?: T.ComponentMeasure;
+ components: ComponentMeasure[];
+ metrics: Metric[];
+ rootComponent: ComponentMeasure;
+ selected?: ComponentMeasure;
}
const BASE_COLUMN_COUNT = 4;
import classNames from 'classnames';
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { ComponentMeasure } from '../../../types/types';
interface Props {
- baseComponent?: T.ComponentMeasure;
+ baseComponent?: ComponentMeasure;
canBePinned?: boolean;
metrics: string[];
- rootComponent: T.ComponentMeasure;
+ rootComponent: ComponentMeasure;
}
const SHORT_NAME_METRICS = [
import { KeyboardCodes } from '../../../helpers/keycodes';
import { translate } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
+import { ComponentMeasure } from '../../../types/types';
import PortfolioNewCodeToggle from './PortfolioNewCodeToggle';
interface Props {
branchLike?: BranchLike;
- component: T.ComponentMeasure;
+ component: ComponentMeasure;
location: Location;
newCodeSelected: boolean;
onSearchClear: () => void;
onNewCodeToggle: (newCode: boolean) => void;
- onSearchResults: (results?: T.ComponentMeasure[]) => void;
+ onSearchResults: (results?: ComponentMeasure[]) => void;
router: Router;
}
import SourceViewer from '../../../components/SourceViewer/SourceViewer';
import { scrollToElement } from '../../../helpers/scrolling';
import { BranchLike } from '../../../types/branch-like';
+import { Issue, Measure } from '../../../types/types';
interface Props {
branchLike?: BranchLike;
component: string;
- componentMeasures: T.Measure[] | undefined;
+ componentMeasures: Measure[] | undefined;
location: Pick<Location, 'query'>;
- onIssueChange?: (issue: T.Issue) => void;
+ onIssueChange?: (issue: Issue) => void;
}
export class SourceViewerWrapper extends React.PureComponent<Props> {
import { BranchLike } from '../../types/branch-like';
import { isPortfolioLike } from '../../types/component';
import { MetricKey } from '../../types/metrics';
+import { Breadcrumb, ComponentMeasure } from '../../types/types';
import {
addComponent,
addComponentBreadcrumbs,
const PAGE_SIZE = 100;
interface Children {
- components: T.ComponentMeasure[];
+ components: ComponentMeasure[];
page: number;
total: number;
}
return isPullRequest(branchLike);
}
-function skipRootDir(breadcrumbs: T.ComponentMeasure[]) {
+function skipRootDir(breadcrumbs: ComponentMeasure[]) {
return breadcrumbs.filter(component => {
return !(component.qualifier === 'DIR' && component.name === '/');
});
}
-function storeChildrenBase(children: T.ComponentMeasure[]) {
+function storeChildrenBase(children: ComponentMeasure[]) {
children.forEach(addComponent);
}
-function storeChildrenBreadcrumbs(parentComponentKey: string, children: T.Breadcrumb[]) {
+function storeChildrenBreadcrumbs(parentComponentKey: string, children: Breadcrumb[]) {
const parentBreadcrumbs = getComponentBreadcrumbs(parentComponentKey);
if (parentBreadcrumbs) {
children.forEach(child => {
qualifier: string,
instance: { mounted: boolean },
branchLike?: BranchLike
-): Promise<{ components: T.ComponentMeasure[]; page: number; total: number }> {
+): Promise<{ components: ComponentMeasure[]; page: number; total: number }> {
const existing = getComponentChildren(componentKey);
if (existing) {
return Promise.resolve({
component: string,
instance: { mounted: boolean },
branchLike?: BranchLike
-): Promise<T.Breadcrumb[]> {
+): Promise<Breadcrumb[]> {
const existing = getComponentBreadcrumbs(component);
if (existing) {
return Promise.resolve(existing);
instance: { mounted: boolean },
branchLike?: BranchLike
): Promise<{
- breadcrumbs: T.Breadcrumb[];
- component: T.ComponentMeasure;
- components: T.ComponentMeasure[];
+ breadcrumbs: Breadcrumb[];
+ component: ComponentMeasure;
+ components: ComponentMeasure[];
page: number;
total: number;
}> {
import * as React from 'react';
import { Profile as BaseProfile } from '../../../api/quality-profiles';
import { Button } from '../../../components/controls/buttons';
+import { Rule, RuleActivation, RuleDetails } from '../../../types/types';
import ActivationFormModal from './ActivationFormModal';
interface Props {
- activation?: T.RuleActivation;
+ activation?: RuleActivation;
buttonText: string;
className?: string;
modalHeader: string;
onDone: (severity: string) => Promise<void>;
profiles: BaseProfile[];
- rule: T.Rule | T.RuleDetails;
+ rule: Rule | RuleDetails;
}
interface State {
import { SEVERITIES } from '../../../helpers/constants';
import { translate } from '../../../helpers/l10n';
import { sanitizeString } from '../../../helpers/sanitize';
+import { Dict, Rule, RuleActivation, RuleDetails } from '../../../types/types';
import { sortProfiles } from '../../quality-profiles/utils';
interface Props {
- activation?: T.RuleActivation;
+ activation?: RuleActivation;
modalHeader: string;
onClose: () => void;
onDone: (severity: string) => Promise<void>;
profiles: Profile[];
- rule: T.Rule | T.RuleDetails;
+ rule: Rule | RuleDetails;
}
interface State {
- params: T.Dict<string>;
+ params: Dict<string>;
profile: string;
severity: string;
submitting: boolean;
}
getParams = ({ activation, rule } = this.props) => {
- const params: T.Dict<string> = {};
+ const params: Dict<string> = {};
if (rule && rule.params) {
for (const param of rule.params) {
params[param.key] = param.defaultValue || '';
const { profile, severity, submitting } = this.state;
const { params = [] } = rule;
const profilesWithDepth = this.getQualityProfilesWithDepth();
- const isCustomRule = !!(rule as T.RuleDetails).templateKey;
+ const isCustomRule = !!(rule as RuleDetails).templateKey;
const activeInAllProfiles = profilesWithDepth.length <= 0;
const isUpdateMode = !!activation;
import { isLoggedIn } from '../../../helpers/users';
import { getCurrentUser, getLanguages, Store } from '../../../store/rootReducer';
import { SecurityStandard } from '../../../types/security';
+import {
+ CurrentUser,
+ Dict,
+ Languages,
+ Paging,
+ RawQuery,
+ Rule,
+ RuleActivation
+} from '../../../types/types';
import {
shouldOpenSonarSourceSecurityFacet,
shouldOpenStandardsChildFacet,
const LIMIT_BEFORE_LOAD_MORE = 5;
interface Props extends WithRouterProps {
- currentUser: T.CurrentUser;
- languages: T.Languages;
+ currentUser: CurrentUser;
+ languages: Languages;
}
interface State {
facets?: Facets;
loading: boolean;
openFacets: OpenFacets;
- openRule?: T.Rule;
- paging?: T.Paging;
+ openRule?: Rule;
+ paging?: Paging;
query: Query;
- referencedProfiles:
T.Dict<Profile>;
- referencedRepositories: T.Dict<{ key: string; language: string; name: string }>;
- rules: T.Rule[];
+ referencedProfiles: Dict<Profile>;
+ referencedRepositories: Dict<{ key: string; language: string; name: string }>;
+ rules: Rule[];
selected?: string;
usingPermalink?: boolean;
}
detachShortcuts = () => key.deleteScope('coding-rules');
- getOpenRule = (props: Props, rules: T.Rule[]) => {
+ getOpenRule = (props: Props, rules: Rule[]) => {
const open = getOpen(props.location.query);
return open && rules.find(rule => rule.key === open);
};
);
};
- makeFetchRequest = (query?: T.RawQuery) =>
+ makeFetchRequest = (query?: RawQuery) =>
searchRules({ ...this.getSearchParameters(), ...query }).then(
({ actives: rawActives, facets: rawFacets, p, ps, rules, total }) => {
const actives = rawActives && parseActives(rawActives);
}
);
- fetchFirstRules = (query?: T.RawQuery) => {
+ fetchFirstRules = (query?: RawQuery) => {
this.setState({ loading: true });
this.makeFetchRequest(query).then(({ actives, facets, paging, rules }) => {
if (this.mounted) {
handleReset = () => this.props.router.push({ pathname: this.props.location.pathname });
/** Tries to take rule by index, or takes the last one */
- pickRuleAround = (rules: T.Rule[], selectedIndex: number | undefined) => {
+ pickRuleAround = (rules: Rule[], selectedIndex: number | undefined) => {
if (selectedIndex === undefined || rules.length === 0) {
return undefined;
}
}
}
-function parseActives(rawActives: T.Dict<T.RuleActivation[]>) {
+function parseActives(rawActives: Dict<RuleActivation[]>) {
const actives: Actives = {};
for (const [rule, activations] of Object.entries(rawActives)) {
actives[rule] = {};
function parseFacets(rawFacets: { property: string; values: { count: number; val: string }[] }[]) {
const facets: Facets = {};
for (const rawFacet of rawFacets) {
- const values: T.Dict<number> = {};
+ const values: Dict<number> = {};
for (const rawValue of rawFacet.values) {
values[rawValue.val] = rawValue.count;
}
import Tooltip from '../../../components/controls/Tooltip';
import { PopupPlacement } from '../../../components/ui/popups';
import { translate } from '../../../helpers/l10n';
+import { Dict, Languages } from '../../../types/types';
import { Query } from '../query';
import BulkChangeModal from './BulkChangeModal';
interface Props {
- languages: T.Languages;
+ languages: Languages;
query: Query;
- referencedProfiles:
T.Dict<Profile>;
+ referencedProfiles: Dict<Profile>;
total: number;
}
import { Alert } from '../../../components/ui/Alert';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { formatMeasure } from '../../../helpers/measures';
+import { Dict, Languages } from '../../../types/types';
import { Query, serializeQuery } from '../query';
interface Props {
action: string;
- languages: T.Languages;
+ languages: Languages;
onClose: () => void;
profile?: Profile;
query: Query;
- referencedProfiles:
T.Dict<Profile>;
+ referencedProfiles: Dict<Profile>;
total: number;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { RuleDetails } from '../../../types/types';
import CustomRuleFormModal from './CustomRuleFormModal';
interface Props {
children: (props: { onClick: () => void }) => React.ReactNode;
- customRule?: T.RuleDetails;
- onDone: (newRuleDetails: T.RuleDetails) => void;
- templateRule: T.RuleDetails;
+ customRule?: RuleDetails;
+ onDone: (newRuleDetails: RuleDetails) => void;
+ templateRule: RuleDetails;
}
interface State {
}
};
- handleDone = (newRuleDetails: T.RuleDetails) => {
+ handleDone = (newRuleDetails: RuleDetails) => {
this.handleModalClose();
this.props.onDone(newRuleDetails);
};
import { translate } from '../../../helpers/l10n';
import { sanitizeString } from '../../../helpers/sanitize';
import { latinize } from '../../../helpers/strings';
+import { Dict, RuleDetails, RuleParameter, RuleType } from '../../../types/types';
interface Props {
- customRule?: T.RuleDetails;
+ customRule?: RuleDetails;
onClose: () => void;
- onDone: (newRuleDetails: T.RuleDetails) => void;
- templateRule: T.RuleDetails;
+ onDone: (newRuleDetails: RuleDetails) => void;
+ templateRule: RuleDetails;
}
interface State {
key: string;
keyModifiedByUser: boolean;
name: string;
- params: T.Dict<string>;
+ params: Dict<string>;
reactivating: boolean;
severity: string;
status: string;
constructor(props: Props) {
super(props);
- const params: T.Dict<string> = {};
+ const params: Dict<string> = {};
if (props.customRule && props.customRule.params) {
for (const param of props.customRule.params) {
params[param.key] = param.defaultValue || '';
</div>
);
- renderTypeOption = ({ value }: { value: T.RuleType }) => {
+ renderTypeOption = ({ value }: { value: RuleType }) => {
return <TypeHelper type={value} />;
};
</div>
);
- renderParameterField = (param: T.RuleParameter) => (
+ renderParameterField = (param: RuleParameter) => (
<div className="modal-field" key={param.key}>
<label className="capitalize" htmlFor={param.key}>
{param.key}
import FacetItemsList from '../../../components/facet/FacetItemsList';
import { translate } from '../../../helpers/l10n';
import { formatMeasure } from '../../../helpers/measures';
+import { Dict } from '../../../types/types';
import { FacetKey } from '../query';
export interface BasicProps {
- onChange: (changes: T.Dict<string | string[] | undefined>) => void;
+ onChange: (changes: Dict<string | string[] | undefined>) => void;
onToggle: (facet: FacetKey) => void;
open: boolean;
- stats?: T.Dict<number>;
+ stats?: Dict<number>;
values: string[];
}
*/
import * as React from 'react';
import { Profile } from '../../../api/quality-profiles';
+import { Dict } from '../../../types/types';
import StandardFacet from '../../issues/sidebar/StandardFacet';
import { Facets, OpenFacets, Query } from '../query';
import ActivationSeverityFacet from './ActivationSeverityFacet';
onFilterChange: (changes: Partial<Query>) => void;
openFacets: OpenFacets;
query: Query;
- referencedProfiles:
T.Dict<Profile>;
- referencedRepositories: T.Dict<{ key: string; language: string; name: string }>;
+ referencedProfiles: Dict<Profile>;
+ referencedRepositories: Dict<{ key: string; language: string; name: string }>;
selectedProfile?: Profile;
}
*/
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { RuleInheritance } from '../../../types/types';
import Facet, { BasicProps } from './Facet';
-interface Props extends T.Omit<BasicProps, 'values'> {
+interface Props extends Omit<BasicProps, 'values'> {
disabled: boolean;
- value: T.RuleInheritance | undefined;
+ value: RuleInheritance | undefined;
}
export default class InheritanceFacet extends React.PureComponent<Props> {
- renderName = (value: T.RuleInheritance) =>
+ renderName = (value: RuleInheritance) =>
translate('coding_rules.filters.inheritance', value.toLowerCase());
render() {
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import PageShortcutsTooltip from '../../../components/ui/PageShortcutsTooltip';
import { translate } from '../../../helpers/l10n';
+import { Paging } from '../../../types/types';
export interface PageActionsProps {
loading: boolean;
onReload: () => void;
- paging?: T.Paging;
+ paging?: Paging;
selectedIndex?: number;
}
import FacetItem from '../../../components/facet/FacetItem';
import FacetItemsList from '../../../components/facet/FacetItemsList';
import { translate } from '../../../helpers/l10n';
+import { Dict } from '../../../types/types';
import { FacetKey, Query } from '../query';
interface Props {
onChange: (changes: Partial<Query>) => void;
onToggle: (facet: FacetKey) => void;
open: boolean;
- referencedProfiles:
T.Dict<Profile>;
+ referencedProfiles: Dict<Profile>;
value: string | undefined;
}
import { translate } from '../../../helpers/l10n';
import { highlightTerm } from '../../../helpers/search';
import { getLanguages, Store } from '../../../store/rootReducer';
+import { Dict } from '../../../types/types';
import { BasicProps } from './Facet';
interface StateProps {
- referencedLanguages: T.Dict<{ key: string; name: string }>;
+ referencedLanguages: Dict<{ key: string; name: string }>;
}
interface Props extends BasicProps, StateProps {
- referencedRepositories: T.Dict<{ key: string; language: string; name: string }>;
+ referencedRepositories: Dict<{ key: string; language: string; name: string }>;
}
export class RepositoryFacet extends React.PureComponent<Props> {
import HelpTooltip from '../../../components/controls/HelpTooltip';
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Dict, RuleActivation, RuleDetails as TypeRuleDetails } from '../../../types/types';
import { Activation, Query } from '../query';
import CustomRuleButton from './CustomRuleButton';
import RuleDetailsCustomRules from './RuleDetailsCustomRules';
onDeactivate: (profile: string, rule: string) => void;
onDelete: (rule: string) => void;
onFilterChange: (changes: Partial<Query>) => void;
- referencedProfiles:
T.Dict<Profile>;
- referencedRepositories: T.Dict<{ key: string; language: string; name: string }>;
+ referencedProfiles: Dict<Profile>;
+ referencedRepositories: Dict<{ key: string; language: string; name: string }>;
ruleKey: string;
selectedProfile?: Profile;
}
interface State {
- actives?: T.RuleActivation[];
+ actives?: RuleActivation[];
loading: boolean;
- ruleDetails?: T.RuleDetails;
+ ruleDetails?: TypeRuleDetails;
}
export default class RuleDetails extends React.PureComponent<Props, State> {
);
};
- handleRuleChange = (ruleDetails: T.RuleDetails) => {
+ handleRuleChange = (ruleDetails: TypeRuleDetails) => {
if (this.mounted) {
this.setState({ ruleDetails });
}
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { getRuleUrl } from '../../../helpers/urls';
+import { Rule, RuleDetails } from '../../../types/types';
import CustomRuleButton from './CustomRuleButton';
interface Props {
canChange?: boolean;
- ruleDetails: T.RuleDetails;
+ ruleDetails: RuleDetails;
}
interface State {
loading: boolean;
- rules?: T.Rule[];
+ rules?: Rule[];
}
export default class RuleDetailsCustomRules extends React.PureComponent<Props, State> {
);
};
- handleRuleCreate = (newRuleDetails: T.RuleDetails) => {
+ handleRuleCreate = (newRuleDetails: RuleDetails) => {
if (this.mounted) {
this.setState(({ rules = [] }: State) => ({
rules: [...rules, newRuleDetails]
});
};
- renderRule = (rule: T.Rule) => (
+ renderRule = (rule: Rule) => (
<tr data-rule={rule.key} key={rule.key}>
<td className="coding-rules-detail-list-name">
<Link to={getRuleUrl(rule.key)}>{rule.name}</Link>
import { Button, ResetButtonLink } from '../../../components/controls/buttons';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { sanitizeString } from '../../../helpers/sanitize';
+import { RuleDetails } from '../../../types/types';
import RemoveExtendedDescriptionModal from './RemoveExtendedDescriptionModal';
interface Props {
canWrite: boolean | undefined;
- onChange: (newRuleDetails: T.RuleDetails) => void;
- ruleDetails: T.RuleDetails;
+ onChange: (newRuleDetails: RuleDetails) => void;
+ ruleDetails: RuleDetails;
}
interface State {
import { translate } from '../../../helpers/l10n';
import { formatMeasure } from '../../../helpers/measures';
import { getIssuesUrl } from '../../../helpers/urls';
+import { AppState, RuleDetails } from '../../../types/types';
interface Props {
- appState: Pick<T.AppState, 'branchesEnabled'>;
- ruleDetails: Pick<T.RuleDetails, 'key' | 'type'>;
+ appState: Pick<AppState, 'branchesEnabled'>;
+ ruleDetails: Pick<RuleDetails, 'key' | 'type'>;
}
interface Project {
import { PopupPlacement } from '../../../components/ui/popups';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { getRuleUrl } from '../../../helpers/urls';
+import { Dict, RuleDetails } from '../../../types/types';
import { Query } from '../query';
import RuleDetailsTagsPopup from './RuleDetailsTagsPopup';
import SimilarRulesFilter from './SimilarRulesFilter';
hideSimilarRulesFilter?: boolean;
onFilterChange: (changes: Partial<Query>) => void;
onTagsChange: (tags: string[]) => void;
- referencedRepositories: T.Dict<{ key: string; language: string; name: string }>;
- ruleDetails: T.RuleDetails;
+ referencedRepositories: Dict<{ key: string; language: string; name: string }>;
+ ruleDetails: RuleDetails;
}
const EXTERNAL_RULE_REPO_PREFIX = 'external_';
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
import { sanitizeString } from '../../../helpers/sanitize';
+import { RuleParameter } from '../../../types/types';
interface Props {
- params: T.RuleParameter[];
+ params: RuleParameter[];
}
export default class RuleDetailsParameters extends React.PureComponent<Props> {
- renderParameter = (param: T.RuleParameter) => (
+ renderParameter = (param: RuleParameter) => (
<tr className="coding-rules-detail-parameter" key={param.key}>
<td className="coding-rules-detail-parameter-name">{param.key}</td>
<td className="coding-rules-detail-parameter-description">
import SeverityHelper from '../../../components/shared/SeverityHelper';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { getQualityProfileUrl } from '../../../helpers/urls';
+import { Dict, RuleActivation, RuleDetails } from '../../../types/types';
import BuiltInQualityProfileBadge from '../../quality-profiles/components/BuiltInQualityProfileBadge';
import ActivationButton from './ActivationButton';
import RuleInheritanceIcon from './RuleInheritanceIcon';
interface Props {
- activations: T.RuleActivation[] | undefined;
+ activations: RuleActivation[] | undefined;
canWrite: boolean | undefined;
onActivate: () => Promise<void>;
onDeactivate: () => Promise<void>;
- referencedProfiles:
T.Dict<Profile>;
- ruleDetails: T.RuleDetails;
+ referencedProfiles: Dict<Profile>;
+ ruleDetails: RuleDetails;
}
export default class RuleDetailsProfiles extends React.PureComponent<Props> {
}
};
- renderInheritedProfile = (activation: T.RuleActivation, profile: Profile) => {
+ renderInheritedProfile = (activation: RuleActivation, profile: Profile) => {
if (!profile.parentName) {
return null;
}
);
};
- renderSeverity = (activation: T.RuleActivation, parentActivation?: T.RuleActivation) => (
+ renderSeverity = (activation: RuleActivation, parentActivation?: RuleActivation) => (
<td className="coding-rules-detail-quality-profile-severity">
<Tooltip overlay={translate('coding_rules.activation_severity')}>
<span>
</td>
);
- renderParameter = (
- param: { key: string; value: string },
- parentActivation?: T.RuleActivation
- ) => {
+ renderParameter = (param: { key: string; value: string }, parentActivation?: RuleActivation) => {
const originalParam =
parentActivation && parentActivation.params.find(p => p.key === param.key);
const originalValue = originalParam && originalParam.value;
);
};
- renderParameters = (activation: T.RuleActivation, parentActivation?: T.RuleActivation) => (
+ renderParameters = (activation: RuleActivation, parentActivation?: RuleActivation) => (
<td className="coding-rules-detail-quality-profile-parameters">
{activation.params.map(param => this.renderParameter(param, parentActivation))}
</td>
);
- renderActions = (activation: T.RuleActivation, profile: Profile) => {
+ renderActions = (activation: RuleActivation, profile: Profile) => {
const canEdit = profile.actions && profile.actions.edit && !profile.isBuiltIn;
const { ruleDetails } = this.props;
const hasParent = activation.inherit !== 'NONE' && profile.parentKey;
);
};
- renderActivation = (activation: T.RuleActivation) => {
+ renderActivation = (activation: RuleActivation) => {
const { activations = [], ruleDetails } = this.props;
const profile = this.props.referencedProfiles[activation.qProfile];
if (!profile) {
*/
import * as React from 'react';
import { colors } from '../../../app/theme';
+import { RuleInheritance } from '../../../types/types';
interface Props {
className?: string;
- inheritance: T.RuleInheritance;
+ inheritance: RuleInheritance;
}
export default function RuleInheritanceIcon({ className, inheritance, ...other }: Props) {
import TagsList from '../../../components/tags/TagsList';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { getRuleUrl } from '../../../helpers/urls';
+import { Rule } from '../../../types/types';
import { Activation, Query } from '../query';
import ActivationButton from './ActivationButton';
import RuleInheritanceIcon from './RuleInheritanceIcon';
onDeactivate: (profile: string, rule: string) => void;
onFilterChange: (changes: Partial<Query>) => void;
onOpen: (ruleKey: string) => void;
- rule: T.Rule;
+ rule: Rule;
selected: boolean;
selectedProfile?: Profile;
}
import TagsIcon from '../../../components/icons/TagsIcon';
import SeverityHelper from '../../../components/shared/SeverityHelper';
import { translate } from '../../../helpers/l10n';
+import { Rule } from '../../../types/types';
import { Query } from '../query';
interface Props {
onFilterChange: (changes: Partial<Query>) => void;
- rule: T.Rule;
+ rule: Rule;
}
export default class SimilarRulesFilter extends React.PureComponent<Props> {
import { translate } from '../../../helpers/l10n';
import Facet, { BasicProps } from './Facet';
-interface Props extends T.Omit<BasicProps, 'onChange' | 'values'> {
+interface Props extends Omit<BasicProps, 'onChange' | 'values'> {
onChange: (changes: { template: boolean | undefined }) => void;
value: boolean | undefined;
}
import { shallow } from 'enzyme';
import * as React from 'react';
+import { Paging } from '../../../../types/types';
import PageActions, { PageActionsProps } from '../PageActions';
it('should render correctly', () => {
expect(shallowRender()).toMatchSnapshot('default');
expect(shallowRender({ loading: true })).toMatchSnapshot('loading');
- expect(shallowRender({ paging: { total: 100 } as T.Paging })).toMatchSnapshot('with paging');
+ expect(shallowRender({ paging: { total: 100 } as Paging })).toMatchSnapshot('with paging');
});
function shallowRender(props: Partial<PageActionsProps> = {}) {
import { deleteRule, getRuleDetails, updateRule } from '../../../../api/rules';
import { mockQualityProfile } from '../../../../helpers/testMocks';
import { waitAndUpdate } from '../../../../helpers/testUtils';
+import { RuleType } from '../../../../types/types';
import RuleDetails from '../RuleDetails';
jest.mock('../../../../api/rules', () => {
repo: 'bar',
severity: 'MAJOR',
status: 'READY',
- type: 'BUG' as T.RuleType
+ type: 'BUG' as RuleType
};
wrapper.instance().handleRuleChange(ruleChange);
import { shallow } from 'enzyme';
import * as React from 'react';
import { change, click, waitAndUpdate } from '../../../../helpers/testUtils';
+import { RuleDetails } from '../../../../types/types';
import RuleDetailsDescription from '../RuleDetailsDescription';
jest.mock('../../../../api/rules', () => ({
updateRule: jest.fn().mockResolvedValue('updatedrule')
}));
-const RULE: T.RuleDetails = {
+const RULE: RuleDetails = {
key: 'squid:S1133',
repo: 'squid',
name: 'Deprecated code should be removed',
type: 'CODE_SMELL'
};
-const EXTERNAL_RULE: T.RuleDetails = {
+const EXTERNAL_RULE: RuleDetails = {
createdAt: '2013-07-26T09:40:51+0200',
key: 'external_xoo:OneExternalIssuePerLine',
repo: 'external_xoo',
type: 'UNKNOWN'
};
-const EXTERNAL_RULE_WITH_DATA: T.RuleDetails = {
+const EXTERNAL_RULE_WITH_DATA: RuleDetails = {
key: 'external_xoo:OneExternalIssueWithDetailsPerLine',
repo: 'external_xoo',
name: 'One external issue per line',
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { RuleDetails } from '../../../../types/types';
import RuleDetailsMeta from '../RuleDetailsMeta';
import RuleDetailsTagsPopup from '../RuleDetailsTagsPopup';
-const RULE: T.RuleDetails = {
+const RULE: RuleDetails = {
key: 'squid:S1133',
repo: 'squid',
name: 'Deprecated code should be removed',
type: 'CODE_SMELL'
};
-const EXTERNAL_RULE: T.RuleDetails = {
+const EXTERNAL_RULE: RuleDetails = {
key: 'external_xoo:OneExternalIssuePerLine',
repo: 'external_xoo',
name: 'xoo:OneExternalIssuePerLine',
type: 'UNKNOWN'
};
-const EXTERNAL_RULE_WITH_DATA: T.RuleDetails = {
+const EXTERNAL_RULE_WITH_DATA: RuleDetails = {
key: 'external_xoo:OneExternalIssueWithDetailsPerLine',
repo: 'external_xoo',
name: 'One external issue per line',
serializeString,
serializeStringArray
} from '../../helpers/query';
+import { Dict, RawQuery, RuleInheritance } from '../../types/types';
export interface Query {
activation: boolean | undefined;
availableSince: Date | undefined;
compareToProfile: string | undefined;
cwe: string[];
- inheritance: T.RuleInheritance | undefined;
+ inheritance: RuleInheritance | undefined;
languages: string[];
owaspTop10: string[];
profile: string | undefined;
export type Facets = { [F in FacetKey]?: Facet };
-export type OpenFacets = T.Dict<boolean>;
+export type OpenFacets = Dict<boolean>;
export interface Activation {
- inherit: T.RuleInheritance;
+ inherit: RuleInheritance;
severity: string;
}
};
}
-export function parseQuery(query: T.RawQuery): Query {
+export function parseQuery(query: RawQuery): Query {
return {
activation: parseAsOptionalBoolean(query.activation),
activationSeverities: parseAsArray(query.active_severities, parseAsString),
};
}
-export function serializeQuery(query: Query): T.RawQuery {
+export function serializeQuery(query: Query): RawQuery {
return cleanQuery({
activation: serializeOptionalBoolean(query.activation),
active_severities: serializeStringArray(query.activationSeverities),
});
}
-export function areQueriesEqual(a: T.RawQuery, b: T.RawQuery) {
+export function areQueriesEqual(a: RawQuery, b: RawQuery) {
return queriesEqual(parseQuery(a), parseQuery(b));
}
return serverFacet === 'active_severities' ? 'activationSeverities' : (serverFacet as FacetKey);
}
-export function getOpen(query: T.RawQuery) {
+export function getOpen(query: RawQuery) {
return query.open;
}
-export function hasRuleKey(query: T.RawQuery) {
+export function hasRuleKey(query: RawQuery) {
return Boolean(query.rule_key);
}
-function parseAsInheritance(value?: string): T.RuleInheritance | undefined {
+function parseAsInheritance(value?: string): RuleInheritance | undefined {
if (value === 'INHERITED' || value === 'NONE' || value === 'OVERRIDES') {
return value;
} else {
}
}
-function serializeInheritance(value: T.RuleInheritance | undefined): string | undefined {
+function serializeInheritance(value: RuleInheritance | undefined): string | undefined {
return value;
}
*/
import { RedirectFunction, RouterState } from 'react-router';
import { lazyLoadComponent } from '../../components/lazyLoadComponent';
+import { RawQuery } from '../../types/types';
import { parseQuery, serializeQuery } from './query';
-function parseHash(hash: string): T.RawQuery {
- const query: T.RawQuery = {};
+function parseHash(hash: string): RawQuery {
+ const query: RawQuery = {};
const parts = hash.split('|');
parts.forEach(part => {
const tokens = part.split('=');
*/
import { ComponentQualifier } from '../../../types/component';
import { MetricKey } from '../../../types/metrics';
+import { ComponentMeasure } from '../../../types/types';
import * as utils from '../utils';
const MEASURES = [
});
describe('extract measure', () => {
- const componentBuilder = (qual: ComponentQualifier): T.ComponentMeasure => {
+ const componentBuilder = (qual: ComponentQualifier): ComponentMeasure => {
return {
qualifier: qual,
key: '1',
import { fetchBranchStatus } from '../../../store/rootActions';
import { BranchLike } from '../../../types/branch-like';
import { ComponentQualifier, isPortfolioLike } from '../../../types/component';
+import {
+ ComponentMeasure,
+ Dict,
+ Issue,
+ MeasureEnhanced,
+ Metric,
+ Period
+} from '../../../types/types';
import Sidebar from '../sidebar/Sidebar';
import '../style.css';
import {
interface Props extends WithRouterProps {
branchLike?: BranchLike;
- component: T.ComponentMeasure;
+ component: ComponentMeasure;
fetchBranchStatus: (branchLike: BranchLike, projectKey: string) => Promise<void>;
}
interface State {
- leakPeriod?: T.Period;
+ leakPeriod?: Period;
loading: boolean;
- measures: T.MeasureEnhanced[];
- metrics: T.Dict<T.Metric>;
+ measures: MeasureEnhanced[];
+ metrics: Dict<Metric>;
}
export class App extends React.PureComponent<Props, State> {
);
}
- getHelmetTitle = (query: Query, displayOverview: boolean, metric?: T.Metric) => {
+ getHelmetTitle = (query: Query, displayOverview: boolean, metric?: Metric) => {
if (displayOverview && query.metric) {
return isProjectOverview(query.metric)
? translate('component_measures.overview.project_overview.facet')
return metric;
};
- handleIssueChange = (_: T.Issue) => {
+ handleIssueChange = (_: Issue) => {
this.refreshBranchStatus();
};
}
};
- renderContent = (displayOverview: boolean, query: Query, metric?: T.Metric) => {
+ renderContent = (displayOverview: boolean, query: Query, metric?: Metric) => {
const { branchLike, component } = this.props;
const { leakPeriod } = this.state;
if (displayOverview) {
import * as React from 'react';
import Tooltip from '../../../components/controls/Tooltip';
import { collapsePath, limitComponentName } from '../../../helpers/path';
+import { ComponentMeasure, ComponentMeasureIntern } from '../../../types/types';
interface Props {
canBrowse: boolean;
- component: T.ComponentMeasure;
+ component: ComponentMeasure;
isLast: boolean;
- handleSelect: (component: T.ComponentMeasureIntern) => void;
+ handleSelect: (component: ComponentMeasureIntern) => void;
}
export default class Breadcrumb extends React.PureComponent<Props> {
import { getBreadcrumbs } from '../../../api/components';
import { getBranchLikeQuery, isSameBranchLike } from '../../../helpers/branch-like';
import { BranchLike } from '../../../types/branch-like';
+import { ComponentMeasure, ComponentMeasureIntern } from '../../../types/types';
import Breadcrumb from './Breadcrumb';
interface Props {
backToFirst: boolean;
branchLike?: BranchLike;
className?: string;
- component: T.ComponentMeasure;
- handleSelect: (component: T.ComponentMeasureIntern) => void;
- rootComponent: T.ComponentMeasure;
+ component: ComponentMeasure;
+ handleSelect: (component: ComponentMeasureIntern) => void;
+ rootComponent: ComponentMeasure;
}
interface State {
- breadcrumbs: T.ComponentMeasure[];
+ breadcrumbs: ComponentMeasure[];
}
export default class Breadcrumbs extends React.PureComponent<Props, State> {
import DateTimeFormatter, { formatterOption } from '../../../components/intl/DateTimeFormatter';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { getPeriodDate, getPeriodLabel } from '../../../helpers/periods';
+import { ComponentMeasure, Period } from '../../../types/types';
interface Props {
className?: string;
- component: T.ComponentMeasure;
- period: T.Period;
+ component: ComponentMeasure;
+ period: Period;
}
export class LeakPeriodLegend extends React.PureComponent<Props & WrappedComponentProps> {
import { isFile, isView } from '../../../types/component';
import { MeasurePageView } from '../../../types/measures';
import { MetricKey } from '../../../types/metrics';
+import {
+ ComponentMeasure,
+ ComponentMeasureEnhanced,
+ ComponentMeasureIntern,
+ Dict,
+ Issue,
+ Measure,
+ Metric,
+ Paging,
+ Period
+} from '../../../types/types';
import { complementary } from '../config/complementary';
import FilesView from '../drilldown/FilesView';
import TreeMapView from '../drilldown/TreeMapView';
interface Props {
branchLike?: BranchLike;
- leakPeriod?: T.Period;
- requestedMetric: Pick<T.Metric, 'key' | 'direction'>;
- metrics: T.Dict<T.Metric>;
- onIssueChange?: (issue: T.Issue) => void;
- rootComponent: T.ComponentMeasure;
+ leakPeriod?: Period;
+ requestedMetric: Pick<Metric, 'key' | 'direction'>;
+ metrics: Dict<Metric>;
+ onIssueChange?: (issue: Issue) => void;
+ rootComponent: ComponentMeasure;
router: InjectedRouter;
selected?: string;
updateQuery: (query: Partial<Query>) => void;
}
interface State {
- baseComponent?: T.ComponentMeasure;
- components: T.ComponentMeasureEnhanced[];
+ baseComponent?: ComponentMeasure;
+ components: ComponentMeasureEnhanced[];
loadingMoreComponents: boolean;
- measure?: T.Measure;
- metric?: T.Metric;
- paging?: T.Paging;
- secondaryMeasure?: T.Measure;
- selectedComponent?: T.ComponentMeasureIntern;
+ measure?: Measure;
+ metric?: Metric;
+ paging?: Paging;
+ secondaryMeasure?: Measure;
+ selectedComponent?: ComponentMeasureIntern;
}
export default class MeasureContent extends React.PureComponent<Props, State> {
getComponentRequestParams(
view: MeasurePageView,
- metric: Pick<T.Metric, 'key' | 'direction'>,
+ metric: Pick<Metric, 'key' | 'direction'>,
options: Object = {}
) {
const strategy = view === 'list' ? 'leaves' : 'children';
this.props.updateQuery({ view });
};
- onOpenComponent = (component: T.ComponentMeasureIntern) => {
+ onOpenComponent = (component: ComponentMeasureIntern) => {
if (isView(this.props.rootComponent.qualifier)) {
const comp = this.state.components.find(
c =>
}
};
- onSelectComponent = (component: T.ComponentMeasureIntern) => {
+ onSelectComponent = (component: ComponentMeasureIntern) => {
this.setState({ selectedComponent: component });
};
selectedIdx={selectedIdx}
selectedComponent={
selectedIdx !== undefined
- ? (this.state.selectedComponent as T.ComponentMeasureEnhanced)
+ ? (this.state.selectedComponent as ComponentMeasureEnhanced)
: undefined
}
view={view}
import { isDiffMetric } from '../../../helpers/measures';
import { getMeasureHistoryUrl } from '../../../helpers/urls';
import { BranchLike } from '../../../types/branch-like';
+import { ComponentMeasure, Measure as TypeMeasure, Metric, Period } from '../../../types/types';
import { hasFullMeasures } from '../utils';
import LeakPeriodLegend from './LeakPeriodLegend';
interface Props {
branchLike?: BranchLike;
- component: T.ComponentMeasure;
- leakPeriod?: T.Period;
+ component: ComponentMeasure;
+ leakPeriod?: Period;
measureValue?: string;
- metric: T.Metric;
- secondaryMeasure?: T.Measure;
+ metric: Metric;
+ secondaryMeasure?: TypeMeasure;
}
export default function MeasureHeader(props: Props) {
import { getBranchLikeQuery, isSameBranchLike } from '../../../helpers/branch-like';
import { BranchLike } from '../../../types/branch-like';
import { isFile } from '../../../types/component';
+import {
+ ComponentMeasure,
+ ComponentMeasureEnhanced,
+ ComponentMeasureIntern,
+ Dict,
+ Issue,
+ Metric,
+ Paging,
+ Period
+} from '../../../types/types';
import BubbleChart from '../drilldown/BubbleChart';
import { BUBBLES_FETCH_LIMIT, enhanceComponent, getBubbleMetrics, hasFullMeasures } from '../utils';
import Breadcrumbs from './Breadcrumbs';
interface Props {
branchLike?: BranchLike;
className?: string;
- component: T.ComponentMeasure;
+ component: ComponentMeasure;
domain: string;
- leakPeriod?: T.Period;
+ leakPeriod?: Period;
loading: boolean;
- metrics: T.Dict<T.Metric>;
- onIssueChange?: (issue: T.Issue) => void;
- rootComponent: T.ComponentMeasure;
- updateLoading: (param: T.Dict<boolean>) => void;
- updateSelected: (component: T.ComponentMeasureIntern) => void;
+ metrics: Dict<Metric>;
+ onIssueChange?: (issue: Issue) => void;
+ rootComponent: ComponentMeasure;
+ updateLoading: (param: Dict<boolean>) => void;
+ updateSelected: (component: ComponentMeasureIntern) => void;
}
interface State {
- components: T.ComponentMeasureEnhanced[];
- paging?: T.Paging;
+ components: ComponentMeasureEnhanced[];
+ paging?: Paging;
}
export default class MeasureOverview extends React.PureComponent<Props, State> {
import { getProjectUrl } from '../../../helpers/urls';
import { BranchLike } from '../../../types/branch-like';
import { isView } from '../../../types/component';
+import {
+ ComponentMeasure,
+ ComponentMeasureIntern,
+ Dict,
+ Issue,
+ Metric,
+ Period
+} from '../../../types/types';
import { Query } from '../utils';
import MeasureOverview from './MeasureOverview';
branchLike?: BranchLike;
className?: string;
domain: string;
- leakPeriod?: T.Period;
- metrics: T.Dict<T.Metric>;
- onIssueChange?: (issue: T.Issue) => void;
- rootComponent: T.ComponentMeasure;
+ leakPeriod?: Period;
+ metrics: Dict<Metric>;
+ onIssueChange?: (issue: Issue) => void;
+ rootComponent: ComponentMeasure;
router: InjectedRouter;
selected?: string;
updateQuery: (query: Partial<Query>) => void;
}
interface State {
- component?: T.ComponentMeasure;
+ component?: ComponentMeasure;
loading: LoadingState;
}
}
};
- updateSelected = (component: T.ComponentMeasureIntern) => {
+ updateSelected = (component: ComponentMeasureIntern) => {
if (this.state.component && isView(this.state.component.qualifier)) {
this.props.router.push(getProjectUrl(component.refKey || component.key, component.branch));
} else {
import TreemapIcon from '../../../components/icons/TreemapIcon';
import { translate } from '../../../helpers/l10n';
import { MeasurePageView } from '../../../types/measures';
+import { Metric } from '../../../types/types';
import { hasList, hasTree, hasTreemap } from '../utils';
interface Props {
className?: string;
- metric: T.Metric;
+ metric: Metric;
handleViewChange: (view: MeasurePageView) => void;
view: MeasurePageView;
}
import { shallow } from 'enzyme';
import * as React from 'react';
import { IntlShape } from 'react-intl';
+import { ComponentMeasure, Period } from '../../../../types/types';
import { LeakPeriodLegend } from '../LeakPeriodLegend';
jest.mock('date-fns', () => {
qualifier: 'APP'
};
-const PERIOD: T.Period = {
+const PERIOD: Period = {
date: '2017-05-16T13:50:02+0200',
index: 1,
mode: 'previous_version',
parameter: '6,4'
};
-const PERIOD_DAYS: T.Period = {
+const PERIOD_DAYS: Period = {
date: '2017-05-16T13:50:02+0200',
index: 1,
mode: 'days',
expect(getWrapper(PROJECT, PERIOD)).toMatchSnapshot();
});
-function getWrapper(component: T.ComponentMeasure, period: T.Period) {
+function getWrapper(component: ComponentMeasure, period: Period) {
return shallow(
<LeakPeriodLegend
component={component}
import { shallow } from 'enzyme';
import * as React from 'react';
import { mockBranch } from '../../../../helpers/mocks/branch-like';
+import { Period } from '../../../../types/types';
import MeasureHeader from '../MeasureHeader';
const METRIC = {
index: 1,
mode: 'previous_version',
parameter: '6,4'
- } as T.Period,
+ } as Period,
measureValue: '3.0',
metric: METRIC
};
+import { Dict } from '../../../types/types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-export const complementary: T.Dict<string[]> = {
+export const complementary: Dict<string[]> = {
coverage: ['uncovered_lines', 'uncovered_conditions'],
line_coverage: ['uncovered_lines'],
branch_coverage: ['uncovered_conditions'],
import { formatMeasure, isDiffMetric } from '../../../helpers/measures';
import { isDefined } from '../../../helpers/types';
import { isProject } from '../../../types/component';
+import {
+ ComponentMeasure,
+ ComponentMeasureEnhanced,
+ ComponentMeasureIntern,
+ Dict,
+ Metric,
+ Paging
+} from '../../../types/types';
import {
BUBBLES_FETCH_LIMIT,
getBubbleMetrics,
const HEIGHT = 500;
interface Props {
- component: T.ComponentMeasure;
- components: T.ComponentMeasureEnhanced[];
+ component: ComponentMeasure;
+ components: ComponentMeasureEnhanced[];
domain: string;
- metrics: T.Dict<T.Metric>;
- paging?: T.Paging;
- updateSelected: (component: T.ComponentMeasureIntern) => void;
+ metrics: Dict<Metric>;
+ paging?: Paging;
+ updateSelected: (component: ComponentMeasureIntern) => void;
}
interface State {
ratingFilters: {}
};
- getMeasureVal = (component: T.ComponentMeasureEnhanced, metric: T.Metric) => {
+ getMeasureVal = (component: ComponentMeasureEnhanced, metric: Metric) => {
const measure = component.measures.find(measure => measure.metric.key === metric.key);
if (!measure) {
return undefined;
};
getTooltip(
- component: T.ComponentMeasureEnhanced,
+ component: ComponentMeasureEnhanced,
values: { x: number; y: number; size: number; colors?: Array<number | undefined> },
- metrics: { x: T.Metric; y: T.Metric; size: T.Metric; colors?: T.Metric[] }
+ metrics: { x: Metric; y: Metric; size: Metric; colors?: Metric[] }
) {
const inner = [
[component.name, isProject(component.qualifier) ? component.branch : undefined]
});
};
- handleBubbleClick = (component: T.ComponentMeasureEnhanced) =>
- this.props.updateSelected(component);
+ handleBubbleClick = (component: ComponentMeasureEnhanced) => this.props.updateSelected(component);
getDescription(domain: string) {
const description = `component_measures.overview.${domain}.description`;
return translatedDescription;
}
- renderBubbleChart(metrics: { x: T.Metric; y: T.Metric; size: T.Metric; colors?: T.Metric[] }) {
+ renderBubbleChart(metrics: { x: Metric; y: Metric; size: Metric; colors?: Metric[] }) {
const { ratingFilters } = this.state;
const items = this.props.components
}
return (
- <OriginalBubbleChart<T.ComponentMeasureEnhanced>
+ <OriginalBubbleChart<ComponentMeasureEnhanced>
formatXTick={formatXTick}
formatYTick={formatYTick}
height={HEIGHT}
);
}
- renderChartHeader(domain: string, sizeMetric: T.Metric, colorsMetric?: T.Metric[]) {
+ renderChartHeader(domain: string, sizeMetric: Metric, colorsMetric?: Metric[]) {
const { ratingFilters } = this.state;
const { paging } = this.props;
} from '../../../types/component';
import { MeasurePageView } from '../../../types/measures';
import { MetricKey } from '../../../types/metrics';
+import { ComponentMeasure, ComponentMeasureEnhanced, Metric } from '../../../types/types';
export interface ComponentCellProps {
branchLike?: BranchLike;
- component: T.ComponentMeasureEnhanced;
- metric: T.Metric;
- rootComponent: T.ComponentMeasure;
+ component: ComponentMeasureEnhanced;
+ metric: Metric;
+ rootComponent: ComponentMeasure;
view: MeasurePageView;
}
import { getLocalizedMetricName } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
import { MeasurePageView } from '../../../types/measures';
+import { ComponentMeasure, ComponentMeasureEnhanced, Dict, Metric } from '../../../types/types';
import { complementary } from '../config/complementary';
import ComponentsListRow from './ComponentsListRow';
import EmptyResult from './EmptyResult';
interface Props {
branchLike?: BranchLike;
- components: T.ComponentMeasureEnhanced[];
- metric: T.Metric;
- metrics: T.Dict<T.Metric>;
- rootComponent: T.ComponentMeasure;
- selectedComponent?: T.ComponentMeasureEnhanced;
+ components: ComponentMeasureEnhanced[];
+ metric: Metric;
+ metrics: Dict<Metric>;
+ rootComponent: ComponentMeasure;
+ selectedComponent?: ComponentMeasureEnhanced;
view: MeasurePageView;
}
import * as React from 'react';
import { BranchLike } from '../../../types/branch-like';
import { MeasurePageView } from '../../../types/measures';
+import { ComponentMeasure, ComponentMeasureEnhanced, Metric } from '../../../types/types';
import ComponentCell from './ComponentCell';
import MeasureCell from './MeasureCell';
interface Props {
branchLike?: BranchLike;
- component: T.ComponentMeasureEnhanced;
+ component: ComponentMeasureEnhanced;
isSelected: boolean;
- otherMetrics: T.Metric[];
- metric: T.Metric;
- rootComponent: T.ComponentMeasure;
+ otherMetrics: Metric[];
+ metric: Metric;
+ rootComponent: ComponentMeasure;
view: MeasurePageView;
}
import { scrollToElement } from '../../../helpers/scrolling';
import { BranchLike } from '../../../types/branch-like';
import { MeasurePageView } from '../../../types/measures';
+import {
+ ComponentMeasure,
+ ComponentMeasureEnhanced,
+ Dict,
+ Metric,
+ Paging
+} from '../../../types/types';
import ComponentsList from './ComponentsList';
interface Props {
branchLike?: BranchLike;
- components: T.ComponentMeasureEnhanced[];
+ components: ComponentMeasureEnhanced[];
defaultShowBestMeasures: boolean;
fetchMore: () => void;
- handleSelect: (component: T.ComponentMeasureEnhanced) => void;
- handleOpen: (component: T.ComponentMeasureEnhanced) => void;
+ handleSelect: (component: ComponentMeasureEnhanced) => void;
+ handleOpen: (component: ComponentMeasureEnhanced) => void;
loadingMore: boolean;
- metric: T.Metric;
- metrics: T.Dict<T.Metric>;
- paging?: T.Paging;
- rootComponent: T.ComponentMeasure;
- selectedComponent?: T.ComponentMeasureEnhanced;
+ metric: Metric;
+ metrics: Dict<Metric>;
+ paging?: Paging;
+ rootComponent: ComponentMeasure;
+ selectedComponent?: ComponentMeasureEnhanced;
selectedIdx?: number;
view: MeasurePageView;
}
this.setState({ showBestMeasures: true });
};
- hasBestValue = (component: T.ComponentMeasureEnhanced) => {
+ hasBestValue = (component: ComponentMeasureEnhanced) => {
const { metric } = this.props;
const focusedMeasure = component.measures.find(measure => measure.metric.key === metric.key);
if (focusedMeasure && isDiffMetric(metric.key)) {
import * as React from 'react';
import Measure from '../../../components/measure/Measure';
import { isDiffMetric } from '../../../helpers/measures';
+import { ComponentMeasureEnhanced, MeasureEnhanced, Metric } from '../../../types/types';
interface Props {
- component: T.ComponentMeasureEnhanced;
- measure?: T.MeasureEnhanced;
- metric: T.Metric;
+ component: ComponentMeasureEnhanced;
+ measure?: MeasureEnhanced;
+ metric: Metric;
}
export default function MeasureCell({ component, measure, metric }: Props) {
import { isDefined } from '../../../helpers/types';
import { BranchLike } from '../../../types/branch-like';
import { MetricKey } from '../../../types/metrics';
+import { ComponentMeasureEnhanced, ComponentMeasureIntern, Metric } from '../../../types/types';
import EmptyResult from './EmptyResult';
interface Props {
branchLike?: BranchLike;
- components: T.ComponentMeasureEnhanced[];
- handleSelect: (component: T.ComponentMeasureIntern) => void;
- metric: T.Metric;
+ components: ComponentMeasureEnhanced[];
+ handleSelect: (component: ComponentMeasureIntern) => void;
+ metric: Metric;
}
interface State {
.domain(['ERROR', 'WARN', 'OK', 'NONE'])
.range(LEVEL_COLORS);
- getPercentColorScale = (metric: T.Metric) => {
+ getPercentColorScale = (metric: Metric) => {
const color = scaleLinear<string, string>().domain([0, 25, 50, 75, 100]);
color.range(metric.higherValuesAreBetter ? [...COLORS].reverse() : COLORS);
return color;
.domain([1, 2, 3, 4, 5])
.range(COLORS);
- getColorScale = (metric: T.Metric) => {
+ getColorScale = (metric: Metric) => {
if (metric.type === 'LEVEL') {
return this.getLevelColorScale();
}
sizeMetric,
sizeValue
}: {
- colorMetric: T.Metric;
+ colorMetric: Metric;
colorValue?: string;
- component: T.ComponentMeasureEnhanced;
- sizeMetric: T.Metric;
+ component: ComponentMeasureEnhanced;
+ sizeMetric: Metric;
sizeValue: number;
}) => {
const formatted =
hasMessage,
translate
} from '../../../helpers/l10n';
+import { MeasureEnhanced } from '../../../types/types';
import {
addMeasureCategories,
filterMeasures,
import FacetMeasureValue from './FacetMeasureValue';
interface Props {
- domain: { name: string; measures: T.MeasureEnhanced[] };
+ domain: { name: string; measures: MeasureEnhanced[] };
onChange: (metric: string) => void;
onToggle: (property: string) => void;
open: boolean;
this.props.onToggle(this.props.domain.name);
};
- hasFacetSelected = (
- domain: { name: string },
- measures: T.MeasureEnhanced[],
- selected: string
- ) => {
+ hasFacetSelected = (domain: { name: string }, measures: MeasureEnhanced[], selected: string) => {
const measureSelected = measures.find(measure => measure.metric.key === selected);
const overviewSelected = domain.name === selected && this.hasOverview(domain.name);
return measureSelected || overviewSelected;
return this.props.showFullMeasures && hasBubbleChart(domain);
};
- renderItemFacetStat = (item: T.MeasureEnhanced) => {
+ renderItemFacetStat = (item: MeasureEnhanced) => {
return hasFacetStat(item.metric.key) ? (
<FacetMeasureValue displayLeak={this.props.showFullMeasures} measure={item} />
) : null;
import * as React from 'react';
import Measure from '../../../components/measure/Measure';
import { isDiffMetric } from '../../../helpers/measures';
+import { MeasureEnhanced } from '../../../types/types';
interface Props {
displayLeak?: boolean;
- measure: T.MeasureEnhanced;
+ measure: MeasureEnhanced;
}
export default function FacetMeasureValue({ measure, displayLeak }: Props) {
import * as React from 'react';
import A11ySkipTarget from '../../../app/components/a11y/A11ySkipTarget';
import { translate } from '../../../helpers/l10n';
+import { Dict, MeasureEnhanced } from '../../../types/types';
import { groupByDomains, KNOWN_DOMAINS, PROJECT_OVERVEW, Query } from '../utils';
import DomainFacet from './DomainFacet';
import ProjectOverviewFacet from './ProjectOverviewFacet';
interface Props {
- measures: T.MeasureEnhanced[];
+ measures: MeasureEnhanced[];
selectedMetric: string;
showFullMeasures: boolean;
updateQuery: (query: Partial<Query>) => void;
}
interface State {
- openFacets: T.Dict<boolean>;
+ openFacets: Dict<boolean>;
}
export default class Sidebar extends React.PureComponent<Props, State> {
}
}
-function getOpenFacets(openFacets: T.Dict<boolean>, { measures, selectedMetric }: Props) {
+function getOpenFacets(openFacets: Dict<boolean>, { measures, selectedMetric }: Props) {
const newOpenFacets = { ...openFacets };
const measure = measures.find(measure => measure.metric.key === selectedMetric);
if (measure && measure.metric && measure.metric.domain) {
import { ComponentQualifier } from '../../types/component';
import { MeasurePageView } from '../../types/measures';
import { MetricKey } from '../../types/metrics';
+import {
+ ComponentMeasure,
+ ComponentMeasureEnhanced,
+ Dict,
+ Measure,
+ MeasureEnhanced,
+ Metric,
+ RawQuery
+} from '../../types/types';
import { bubbles } from './config/bubbles';
import { domains } from './config/domains';
'new_info_violations'
];
-export function filterMeasures(measures: T.MeasureEnhanced[]): T.MeasureEnhanced[] {
+export function filterMeasures(measures: MeasureEnhanced[]): MeasureEnhanced[] {
return measures.filter(measure => !BANNED_MEASURES.includes(measure.metric.key));
}
export function sortMeasures(
domainName: string,
- measures: Array<T.MeasureEnhanced | string>
-): Array<T.MeasureEnhanced | string> {
+ measures: Array<MeasureEnhanced | string>
+): Array<MeasureEnhanced | string> {
const config = domains[domainName] || {};
const configOrder = config.order || [];
return sortBy(measures, [
- (item: T.MeasureEnhanced | string) => {
+ (item: MeasureEnhanced | string) => {
if (typeof item === 'string') {
return configOrder.indexOf(item);
}
const idx = configOrder.indexOf(item.metric.key);
return idx >= 0 ? idx : configOrder.length;
},
- (item: T.MeasureEnhanced | string) =>
+ (item: MeasureEnhanced | string) =>
typeof item === 'string' ? item : getLocalizedMetricName(item.metric)
]);
}
-export function addMeasureCategories(domainName: string, measures: T.MeasureEnhanced[]) {
+export function addMeasureCategories(domainName: string, measures: MeasureEnhanced[]) {
const categories = domains[domainName] && domains[domainName].categories;
if (categories && categories.length > 0) {
return [...categories, ...measures];
}
export function enhanceComponent(
- component: T.ComponentMeasure,
- metric: Pick<T.Metric, 'key'> | undefined,
- metrics: T.Dict<T.Metric>
-): T.ComponentMeasureEnhanced {
+ component: ComponentMeasure,
+ metric: Pick<Metric, 'key'> | undefined,
+ metrics: Dict<Metric>
+): ComponentMeasureEnhanced {
if (!component.measures) {
return { ...component, measures: [] };
}
].includes(metricKey as MetricKey);
}
-export function banQualityGateMeasure({
- measures = [],
- qualifier
-}: T.ComponentMeasure): T.Measure[] {
+export function banQualityGateMeasure({ measures = [], qualifier }: ComponentMeasure): Measure[] {
const bannedMetrics: string[] = [];
if (ComponentQualifier.Portfolio !== qualifier && ComponentQualifier.SubPortfolio !== qualifier) {
bannedMetrics.push('alert_status');
return measures.filter(measure => !bannedMetrics.includes(measure.metric));
}
-export const groupByDomains = memoize((measures: T.MeasureEnhanced[]) => {
+export const groupByDomains = memoize((measures: MeasureEnhanced[]) => {
const domains = toPairs(groupBy(measures, measure => measure.metric.domain)).map(r => ({
name: r[0],
measures: r[1]
}));
return sortBy(domains, [
- (domain: { name: string; measures: T.MeasureEnhanced[] }) => {
+ (domain: { name: string; measures: MeasureEnhanced[] }) => {
const idx = KNOWN_DOMAINS.indexOf(domain.name);
return idx >= 0 ? idx : KNOWN_DOMAINS.length;
},
return !branch || isBranch(branch);
}
-export function getMeasuresPageMetricKeys(metrics: T.Dict<T.Metric>, branch?: BranchLike) {
+export function getMeasuresPageMetricKeys(metrics: Dict<Metric>, branch?: BranchLike) {
const metricKeys = getDisplayMetrics(Object.values(metrics)).map(metric => metric.key);
if (isPullRequest(branch)) {
}
}
-export function getBubbleMetrics(domain: string, metrics: T.Dict<T.Metric>) {
+export function getBubbleMetrics(domain: string, metrics: Dict<Metric>) {
const conf = bubbles[domain];
return {
x: metrics[conf.x],
}
export const parseQuery = memoize(
- (urlQuery: T.RawQuery): Query => {
+ (urlQuery: RawQuery): Query => {
const metric = parseAsString(urlQuery['metric']) || DEFAULT_METRIC;
return {
metric,
} from '../../../api/alm-integrations';
import { AzureProject, AzureRepository } from '../../../types/alm-integration';
import { AlmSettingsInstance } from '../../../types/alm-settings';
+import { Dict } from '../../../types/types';
import AzureCreateProjectRenderer from './AzureProjectCreateRenderer';
interface Props extends Pick<WithRouterProps, 'location' | 'router'> {
interface State {
importing: boolean;
loading: boolean;
- loadingRepositories: T.Dict<boolean>;
+ loadingRepositories: Dict<boolean>;
patIsValid?: boolean;
projects?: AzureProject[];
- repositories:
T.Dict<AzureRepository[]>;
+ repositories: Dict<AzureRepository[]>;
searching?: boolean;
- searchResults?:
T.Dict<AzureRepository[]>;
+ searchResults?: Dict<AzureRepository[]>;
searchQuery?: string;
selectedRepository?: AzureRepository;
settings?: AlmSettingsInstance;
import { getGlobalSettingsUrl } from '../../../helpers/urls';
import { AzureProject, AzureRepository } from '../../../types/alm-integration';
import { AlmKeys, AlmSettingsInstance } from '../../../types/alm-settings';
+import { Dict } from '../../../types/types';
import { ALM_INTEGRATION } from '../../settings/components/AdditionalCategoryKeys';
import AzurePersonalAccessTokenForm from './AzurePersonalAccessTokenForm';
import AzureProjectsList from './AzureProjectsList';
canAdmin?: boolean;
importing: boolean;
loading: boolean;
- loadingRepositories: T.Dict<boolean>;
+ loadingRepositories: Dict<boolean>;
onImportRepository: () => void;
onOpenProject: (key: string) => void;
onPersonalAccessTokenCreate: (token: string) => void;
onSearch: (query: string) => void;
onSelectRepository: (repository: AzureRepository) => void;
projects?: AzureProject[];
- repositories:
T.Dict<AzureRepository[]>;
+ repositories: Dict<AzureRepository[]>;
searching?: boolean;
- searchResults?:
T.Dict<AzureRepository[]>;
+ searchResults?: Dict<AzureRepository[]>;
searchQuery?: string;
selectedRepository?: AzureRepository;
settings?: AlmSettingsInstance;
import { Alert } from '../../../components/ui/Alert';
import { translate } from '../../../helpers/l10n';
import { AzureProject, AzureRepository } from '../../../types/alm-integration';
+import { Dict } from '../../../types/types';
import AzureProjectAccordion from './AzureProjectAccordion';
import { CreateProjectModes } from './types';
export interface AzureProjectsListProps {
importing: boolean;
- loadingRepositories: T.Dict<boolean>;
+ loadingRepositories: Dict<boolean>;
onOpenProject: (key: string) => void;
onSelectRepository: (repository: AzureRepository) => void;
projects?: AzureProject[];
- repositories:
T.Dict<AzureRepository[]>;
- searchResults?:
T.Dict<AzureRepository[]>;
+ repositories: Dict<AzureRepository[]>;
+ searchResults?: Dict<AzureRepository[]>;
searchQuery?: string;
selectedRepository?: AzureRepository;
}
} from '../../../api/alm-integrations';
import { BitbucketCloudRepository } from '../../../types/alm-integration';
import { AlmSettingsInstance } from '../../../types/alm-settings';
+import { Paging } from '../../../types/types';
import BitbucketCloudProjectCreateRenderer from './BitbucketCloudProjectCreateRender';
interface Props extends Pick<WithRouterProps, 'location' | 'router'> {
isLastPage?: boolean;
loading: boolean;
loadingMore: boolean;
- projectsPaging: Omit<T.Paging, 'total'>;
+ projectsPaging: Omit<Paging, 'total'>;
resetPat: boolean;
repositories: BitbucketCloudRepository[];
searching: boolean;
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { getBaseUrl } from '../../../helpers/system';
import { AlmKeys } from '../../../types/alm-settings';
+import { AppState } from '../../../types/types';
import { CreateProjectModes } from './types';
export interface CreateProjectModeSelectionProps {
almCounts: {
[k in AlmKeys]: number;
};
- appState: Pick<T.AppState, 'canAdmin'>;
+ appState: Pick<AppState, 'canAdmin'>;
loadingBindings: boolean;
onSelectMode: (mode: CreateProjectModes) => void;
onConfigMode: (mode: AlmKeys) => void;
import { translate } from '../../../helpers/l10n';
import { getProjectUrl } from '../../../helpers/urls';
import { AlmKeys, AlmSettingsInstance } from '../../../types/alm-settings';
+import { AppState, LoggedInUser } from '../../../types/types';
import AlmBindingDefinitionForm from '../../settings/components/almIntegration/AlmBindingDefinitionForm';
import AzureProjectCreate from './AzureProjectCreate';
import BitbucketCloudProjectCreate from './BitbucketCloudProjectCreate';
import { CreateProjectModes } from './types';
interface Props extends Pick<WithRouterProps, 'router' | 'location'> {
- appState: Pick<T.AppState, 'canAdmin' | 'branchesEnabled'>;
- currentUser: T.LoggedInUser;
+ appState: Pick<AppState, 'canAdmin' | 'branchesEnabled'>;
+ currentUser: LoggedInUser;
}
interface State {
import { getHostUrl } from '../../../helpers/urls';
import { GithubOrganization, GithubRepository } from '../../../types/alm-integration';
import { AlmKeys, AlmSettingsInstance } from '../../../types/alm-settings';
+import { Paging } from '../../../types/types';
import GitHubProjectCreateRenderer from './GitHubProjectCreateRenderer';
interface Props extends Pick<WithRouterProps, 'location' | 'router'> {
loadingOrganizations: boolean;
loadingRepositories: boolean;
organizations: GithubOrganization[];
- repositoryPaging: T.Paging;
+ repositoryPaging: Paging;
repositories: GithubRepository[];
searchQuery: string;
selectedOrganization?: GithubOrganization;
import { getProjectUrl } from '../../../helpers/urls';
import { GithubOrganization, GithubRepository } from '../../../types/alm-integration';
import { ComponentQualifier } from '../../../types/component';
+import { Paging } from '../../../types/types';
import CreateProjectPageHeader from './CreateProjectPageHeader';
export interface GitHubProjectCreateRendererProps {
onSelectRepository: (key: string) => void;
organizations: GithubOrganization[];
repositories?: GithubRepository[];
- repositoryPaging: T.Paging;
+ repositoryPaging: Paging;
searchQuery: string;
selectedOrganization?: GithubOrganization;
selectedRepository?: GithubRepository;
import { getGitlabProjects, importGitlabProject } from '../../../api/alm-integrations';
import { GitlabProject } from '../../../types/alm-integration';
import { AlmSettingsInstance } from '../../../types/alm-settings';
+import { Paging } from '../../../types/types';
import GitlabProjectCreateRenderer from './GitlabProjectCreateRenderer';
interface Props extends Pick<WithRouterProps, 'location' | 'router'> {
loading: boolean;
loadingMore: boolean;
projects?: GitlabProject[];
- projectsPaging: T.Paging;
+ projectsPaging: Paging;
resetPat: boolean;
searching: boolean;
searchQuery: string;
import { getBaseUrl } from '../../../helpers/system';
import { GitlabProject } from '../../../types/alm-integration';
import { AlmKeys, AlmSettingsInstance } from '../../../types/alm-settings';
+import { Paging } from '../../../types/types';
import CreateProjectPageHeader from './CreateProjectPageHeader';
import GitlabProjectSelectionForm from './GitlabProjectSelectionForm';
import PersonalAccessTokenForm from './PersonalAccessTokenForm';
onPersonalAccessTokenCreated: () => void;
onSearch: (searchQuery: string) => void;
projects?: GitlabProject[];
- projectsPaging: T.Paging;
+ projectsPaging: Paging;
resetPat: boolean;
searching: boolean;
searchQuery: string;
import { getProjectUrl } from '../../../helpers/urls';
import { GitlabProject } from '../../../types/alm-integration';
import { ComponentQualifier } from '../../../types/component';
+import { Paging } from '../../../types/types';
import { CreateProjectModes } from './types';
export interface GitlabProjectSelectionFormProps {
onLoadMore: () => void;
onSearch: (searchQuery: string) => void;
projects?: GitlabProject[];
- projectsPaging: T.Paging;
+ projectsPaging: Paging;
searching: boolean;
searchQuery: string;
}
/* eslint-disable no-console */
import { filterContent, ParsedContent } from '../../../helpers/markdown';
import { mockDocumentationMarkdown } from '../../../helpers/testMocks';
+import { Dict } from '../../../types/types';
jest.mock('remark', () => () => ({
parse: jest.fn().mockReturnValue({})
key: 'tata'
};
- const overrides:
T.Dict<ParsedContent> = {};
+ const overrides: Dict<ParsedContent> = {};
overrides[foo.url] = { frontmatter: overrideFooDoc, content: overrideFooDoc.content };
overrides[`analysis/languages/${newDoc.key}`] = { frontmatter: newDoc, content: newDoc.content };
const pages = getPages(overrides);
console.error = originalConsoleError;
});
-function getPages(overrides:
T.Dict<ParsedContent> = {}) {
+function getPages(overrides: Dict<ParsedContent> = {}) {
// This allows the use of out-of-scope data inside jest.mock
// Usually, it is impossible as jest.mock'ed module is hoisted on the top of the file
return jest.requireActual('../pages').default(overrides);
import { addSideBarClass, removeSideBarClass } from '../../../helpers/pages';
import { isDefined } from '../../../helpers/types';
import { InstalledPlugin, PluginType } from '../../../types/plugins';
+import { Dict } from '../../../types/types';
import { getUrlsList } from '../navTreeUtils';
import getPages from '../pages';
import '../styles.css';
path => regex.test(path) && path !== `/${LANGUAGES_BASE_URL}/overview/`
);
- const parsedContent:
T.Dict<ParsedContent> = {};
+ const parsedContent: Dict<ParsedContent> = {};
pluginsWithDoc.filter(isDefined).forEach(plugin => {
const parsed = separateFrontMatter(plugin.content);
import classNames from 'classnames';
import * as React from 'react';
import { Link } from 'react-router';
+import { Dict } from '../../../types/types';
import { cutWords, DocumentationEntry, highlightMarks } from '../utils';
export interface SearchResult {
exactMatch?: boolean;
- highlights: T.Dict<[number, number][]>;
+ highlights: Dict<[number, number][]>;
longestTerm: string;
page: DocumentationEntry;
query: string;
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-import { DocNavigationItem } from 'Docs/@types/types';
+import { Dict, DocNavigationItem } from 'Docs/@types/types';
import { sortBy } from 'lodash';
import lunr, { LunrBuilder, LunrIndex, LunrToken } from 'lunr';
import * as React from 'react';
return undefined;
}
- const highlights: T.Dict<[number, number][]> = {};
+ const highlights: Dict<[number, number][]> = {};
let longestTerm = '';
let exactMatch = false;
import remark from 'remark';
import visit from 'unist-util-visit';
import { filterContent, ParsedContent, separateFrontMatter } from '../../helpers/markdown';
+import { Dict } from '../../types/types';
import Docs from './documentation.directory-loader';
import { DocumentationEntry, DocumentationEntryScope } from './utils';
-export default function getPages(
- parsedOverrides: T.Dict<ParsedContent> = {}
-): DocumentationEntry[] {
+export default function getPages(parsedOverrides: Dict<ParsedContent> = {}): DocumentationEntry[] {
// Get entries, merge with overrides if applicable.
const pages = ((Docs as unknown) as Array<{ content: string; path: string }>).map(file => {
let parsed = separateFrontMatter(file.content);
import SearchBox from '../../../components/controls/SearchBox';
import { translate } from '../../../helpers/l10n';
import { omitNil } from '../../../helpers/request';
+import { Group, Paging } from '../../../types/types';
import DeleteForm from './DeleteForm';
import Form from './Form';
import Header from './Header';
import List from './List';
interface State {
- groups?: T.Group[];
- editedGroup?: T.Group;
- groupToBeDeleted?: T.Group;
+ groups?: Group[];
+ editedGroup?: Group;
+ groupToBeDeleted?: Group;
loading: boolean;
- paging?: T.Paging;
+ paging?: Paging;
query: string;
}
this.setState({ editedGroup: undefined });
};
- openDeleteForm = (group: T.Group) => {
+ openDeleteForm = (group: Group) => {
this.setState({ groupToBeDeleted: group });
};
- openEditForm = (group: T.Group) => {
+ openEditForm = (group: Group) => {
this.setState({ editedGroup: group });
};
import SimpleModal from '../../../components/controls/SimpleModal';
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Group } from '../../../types/types';
interface Props {
- group: T.Group;
+ group: Group;
onClose: () => void;
onSubmit: () => Promise<void>;
}
import { ButtonIcon } from '../../../components/controls/buttons';
import BulletListIcon from '../../../components/icons/BulletListIcon';
import { translate } from '../../../helpers/l10n';
+import { Group } from '../../../types/types';
import EditMembersModal from './EditMembersModal';
interface Props {
- group: T.Group;
+ group: Group;
onEdit: () => void;
}
SelectListSearchParams
} from '../../../components/controls/SelectList';
import { translate } from '../../../helpers/l10n';
+import { Group, UserSelected } from '../../../types/types';
interface Props {
- group: T.Group;
+ group: Group;
onClose: () => void;
}
interface State {
lastSearchParams?: SelectListSearchParams;
needToReload: boolean;
- users: T.UserSelected[];
+ users: UserSelected[];
usersTotalCount?: number;
selectedUsers: string[];
}
import MandatoryFieldMarker from '../../../components/ui/MandatoryFieldMarker';
import MandatoryFieldsExplanation from '../../../components/ui/MandatoryFieldsExplanation';
import { translate } from '../../../helpers/l10n';
+import { Group } from '../../../types/types';
interface Props {
confirmButtonText: string;
- group?: T.Group;
+ group?: Group;
header: string;
onClose: () => void;
onSubmit: (data: { description: string; name: string }) => Promise<void>;
import { sortBy } from 'lodash';
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { Group } from '../../../types/types';
import ListItem from './ListItem';
interface Props {
- groups: T.Group[];
- onDelete: (group: T.Group) => void;
- onEdit: (group: T.Group) => void;
+ groups: Group[];
+ onDelete: (group: Group) => void;
+ onEdit: (group: Group) => void;
onEditMembers: () => void;
showAnyone: boolean;
}
ActionsDropdownItem
} from '../../../components/controls/ActionsDropdown';
import { translate } from '../../../helpers/l10n';
+import { Group } from '../../../types/types';
import EditMembers from './EditMembers';
export interface ListItemProps {
- group: T.Group;
- onDelete: (group: T.Group) => void;
- onEdit: (group: T.Group) => void;
+ group: Group;
+ onDelete: (group: Group) => void;
+ onEdit: (group: Group) => void;
onEditMembers: () => void;
}
import { fetchBranchStatus } from '../../../store/rootActions';
import { getCurrentUser, Store } from '../../../store/rootReducer';
import { FetchIssuesPromise } from '../../../types/issues';
+import { RawQuery } from '../../../types/types';
const IssuesAppContainer = lazyLoadComponent(() => import('./IssuesApp'), 'IssuesAppContainer');
fetchIssues
});
-const fetchIssues = (query: T.RawQuery) => {
+const fetchIssues = (query: RawQuery) => {
return searchIssues({
...query,
additionalFields: '_all',
import Avatar from '../../../components/ui/Avatar';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { isLoggedIn, isUserActive } from '../../../helpers/users';
+import { Component, CurrentUser, Dict, Issue, IssueType, Paging } from '../../../types/types';
import { searchAssignees } from '../utils';
interface AssigneeOption {
}
interface Props {
- component: T.Component | undefined;
- currentUser: T.CurrentUser;
- fetchIssues: (x: {}) => Promise<{ issues: T.Issue[]; paging: T.Paging }>;
+ component: Component | undefined;
+ currentUser: CurrentUser;
+ fetchIssues: (x: {}) => Promise<{ issues: Issue[]; paging: Paging }>;
onClose: () => void;
onDone: () => void;
}
interface State extends FormFields {
initialTags: Array<{ label: string; value: string }>;
- issues: T.Issue[];
+ issues: Issue[];
// used for initial loading of issues
loading: boolean;
- paging?: T.Paging;
+ paging?: Paging;
// used when submitting a form
submitting: boolean;
}
);
};
- getAvailableTransitions(issues: T.Issue[]) {
- const transitions: T.Dict<number> = {};
+ getAvailableTransitions(issues: Issue[]) {
+ const transitions: Dict<number> = {};
issues.forEach(issue => {
if (issue.transitions) {
issue.transitions.forEach(t => {
return null;
}
- const types: T.IssueType[] = ['BUG', 'VULNERABILITY', 'CODE_SMELL'];
+ const types: IssueType[] = ['BUG', 'VULNERABILITY', 'CODE_SMELL'];
const options = types.map(type => ({ label: translate('issue.type', type), value: type }));
const optionRenderer = (option: { label: string; value: string }) => (
}
function hasAction(action: string) {
- return (issue: T.Issue) => issue.actions && issue.actions.includes(action);
+ return (issue: Issue) => issue.actions && issue.actions.includes(action);
}
function promptCreateTag(label: string) {
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { collapsePath, limitComponentName } from '../../../helpers/path';
import { ComponentQualifier, isView } from '../../../types/component';
+import { Component, Issue } from '../../../types/types';
import { getSelectedLocation } from '../utils';
interface Props {
- component?: T.Component;
- issue: T.Issue;
+ component?: Component;
+ issue: Issue;
selectedFlowIndex?: number;
selectedLocationIndex?: number;
}
ReferencedRule
} from '../../../types/issues';
import { SecurityStandard } from '../../../types/security';
+import {
+ Component,
+ CurrentUser,
+ Dict,
+ Issue,
+ Paging,
+ RawQuery,
+ UserBase
+} from '../../../types/types';
import * as actions from '../actions';
import ConciseIssuesList from '../conciseIssuesList/ConciseIssuesList';
import ConciseIssuesListHeader from '../conciseIssuesList/ConciseIssuesListHeader';
interface Props {
branchLike?: BranchLike;
- component?: T.Component;
- currentUser: T.CurrentUser;
+ component?: Component;
+ currentUser: CurrentUser;
fetchBranchStatus: (branchLike: BranchLike, projectKey: string) => void;
- fetchIssues: (query: T.RawQuery) => Promise<FetchIssuesPromise>;
+ fetchIssues: (query: RawQuery) => Promise<FetchIssuesPromise>;
location: Location;
onBranchesChange?: () => void;
router: Pick<Router, 'push' | 'replace'>;
checkAll?: boolean;
checked: string[];
effortTotal?: number;
- facets: T.Dict<Facet>;
- issues: T.Issue[];
+ facets: Dict<Facet>;
+ issues: Issue[];
loading: boolean;
- loadingFacets: T.Dict<boolean>;
+ loadingFacets: Dict<boolean>;
loadingMore: boolean;
locationsNavigator: boolean;
myIssues: boolean;
- openFacets: T.Dict<boolean>;
- openIssue?: T.Issue;
+ openFacets: Dict<boolean>;
+ openIssue?: Issue;
openPopup?: { issue: string; name: string };
- paging?: T.Paging;
+ paging?: Paging;
query: Query;
- referencedComponentsById: T.Dict<ReferencedComponent>;
- referencedComponentsByKey: T.Dict<ReferencedComponent>;
- referencedLanguages: T.Dict<ReferencedLanguage>;
- referencedRules: T.Dict<ReferencedRule>;
- referencedUsers: T.Dict<T.UserBase>;
+ referencedComponentsById: Dict<ReferencedComponent>;
+ referencedComponentsByKey: Dict<ReferencedComponent>;
+ referencedLanguages: Dict<ReferencedLanguage>;
+ referencedRules: Dict<ReferencedRule>;
+ referencedUsers: Dict<UserBase>;
selected?: string;
selectedFlowIndex?: number;
selectedLocationIndex?: number;
return index !== -1 ? index : undefined;
}
- getOpenIssue = (props: Props, issues: T.Issue[]) => {
+ getOpenIssue = (props: Props, issues: Issue[]) => {
const open = getOpen(props.location.query);
return open ? issues.find(issue => issue.key === open) : undefined;
};
createdAfterIncludesTime = () => Boolean(this.props.location.query.createdAfter?.includes('T'));
- fetchIssues = (additional: T.RawQuery, requestFacets = false): Promise<FetchIssuesPromise> => {
+ fetchIssues = (additional: RawQuery, requestFacets = false): Promise<FetchIssuesPromise> => {
const { component } = this.props;
const { myIssues, openFacets, query } = this.state;
.join(',')
: undefined;
- const parameters: T.Dict<string | undefined> = {
+ const parameters: Dict<string | undefined> = {
...getBranchLikeQuery(this.props.branchLike),
componentKeys: component && component.key,
s: 'FILE_LINE',
this.setState({ checked: [], loading: true });
if (openIssueKey !== undefined) {
- fetchPromise = this.fetchIssuesUntil(1, (pageIssues: T.Issue[], paging: T.Paging) => {
+ fetchPromise = this.fetchIssuesUntil(1, (pageIssues: Issue[], paging: Paging) => {
if (
paging.total <= paging.pageIndex * paging.pageSize ||
paging.pageIndex * paging.pageSize >= MAX_INITAL_FETCH
fetchIssuesUntil = (
page: number,
- done: (pageIssues: T.Issue[], paging: T.Paging) => boolean
+ done: (pageIssues: Issue[], paging: Paging) => boolean
): Promise<FetchIssuesPromise> => {
- const recursiveFetch = (p: number, prevIssues: T.Issue[]): Promise<FetchIssuesPromise> => {
+ const recursiveFetch = (p: number, prevIssues: Issue[]): Promise<FetchIssuesPromise> => {
return this.fetchIssuesPage(p).then(({ issues: pageIssues, paging, ...other }) => {
const issues = [...prevIssues, ...pageIssues];
return done(pageIssues, paging)
return Promise.reject(undefined);
}
- const isSameComponent = (issue: T.Issue) => issue.component === openIssue.component;
+ const isSameComponent = (issue: Issue) => issue.component === openIssue.component;
- const done = (pageIssues: T.Issue[], p: T.Paging) => {
+ const done = (pageIssues: Issue[], p: Paging) => {
const lastIssue = pageIssues[pageIssues.length - 1];
if (p.total <= p.pageIndex * p.pageSize) {
return true;
getCheckedIssues = () => {
const issues = this.state.checked
.map(checked => this.state.issues.find(issue => issue.key === checked))
- .filter((issue): issue is T.Issue => issue !== undefined);
+ .filter((issue): issue is Issue => issue !== undefined);
const paging = { pageIndex: 1, pageSize: issues.length, total: issues.length };
return Promise.resolve({ issues, paging });
};
- getButtonLabel = (checked: string[], checkAll = false, paging?: T.Paging) => {
+ getButtonLabel = (checked: string[], checkAll = false, paging?: Paging) => {
if (checked.length === 0) {
return translate('bulk_change');
}
}));
};
- handleIssueChange = (issue: T.Issue) => {
+ handleIssueChange = (issue: Issue) => {
this.refreshBranchStatus();
this.setState(state => ({
issues: state.issues.map(candidate => (candidate.key === issue.key ? issue : candidate)),
);
}
- renderSide(openIssue: T.Issue | undefined) {
+ renderSide(openIssue: Issue | undefined) {
const { canBrowseAllChildProjects, qualifier = ComponentQualifier.Project } =
this.props.component || {};
return (
paging,
selectedIndex
}: {
- openIssue: T.Issue | undefined;
- paging: T.Paging | undefined;
+ openIssue: Issue | undefined;
+ paging: Paging | undefined;
selectedIndex: number | undefined;
}) {
return openIssue ? (
*/
import * as React from 'react';
import { BranchLike } from '../../../types/branch-like';
+import { Component, Issue } from '../../../types/types';
import { Query, scrollToIssue } from '../utils';
import ListItem from './ListItem';
interface Props {
branchLike: BranchLike | undefined;
checked: string[];
- component: T.Component | undefined;
- issues: T.Issue[];
+ component: Component | undefined;
+ issues: Issue[];
onFilterChange: (changes: Partial<Query>) => void;
- onIssueChange: (issue: T.Issue) => void;
+ onIssueChange: (issue: Issue) => void;
onIssueCheck: ((issueKey: string) => void) | undefined;
onIssueClick: (issueKey: string) => void;
onPopupToggle: (issue: string, popupName: string, open?: boolean) => void;
openPopup: { issue: string; name: string } | undefined;
- selectedIssue: T.Issue | undefined;
+ selectedIssue: Issue | undefined;
}
interface State {
import SourceViewer from '../../../components/SourceViewer/SourceViewer';
import { scrollToElement } from '../../../helpers/scrolling';
import { BranchLike } from '../../../types/branch-like';
+import { Issue } from '../../../types/types';
import CrossComponentSourceViewer from '../crossComponentSourceViewer/CrossComponentSourceViewer';
import { getLocations, getSelectedLocation } from '../utils';
interface Props {
branchLike: BranchLike | undefined;
- issues: T.Issue[];
- loadIssues: (component: string, from: number, to: number) => Promise<T.Issue[]>;
+ issues: Issue[];
+ loadIssues: (component: string, from: number, to: number) => Promise<Issue[]>;
locationsNavigator: boolean;
- onIssueChange: (issue: T.Issue) => void;
+ onIssueChange: (issue: Issue) => void;
onIssueSelect: (issueKey: string) => void;
onLocationSelect: (index: number) => void;
- openIssue: T.Issue;
+ openIssue: Issue;
selectedFlowIndex: number | undefined;
selectedLocationIndex: number | undefined;
}
import * as React from 'react';
import Issue from '../../../components/issue/Issue';
import { BranchLike } from '../../../types/branch-like';
+import { Component, Issue as TypeIssue } from '../../../types/types';
import { Query } from '../utils';
import ComponentBreadcrumbs from './ComponentBreadcrumbs';
interface Props {
branchLike: BranchLike | undefined;
checked: boolean;
- component: T.Component | undefined;
- issue: T.Issue;
- onChange: (issue: T.Issue) => void;
+ component: Component | undefined;
+ issue: TypeIssue;
+ onChange: (issue: TypeIssue) => void;
onCheck: ((issueKey: string) => void) | undefined;
onClick: (issueKey: string) => void;
onFilterChange: (changes: Partial<Query>) => void;
onPopupToggle: (issue: string, popupName: string, open?: boolean) => void;
openPopup: string | undefined;
- previousIssue: T.Issue | undefined;
+ previousIssue: TypeIssue | undefined;
selected: boolean;
}
export default class ListItem extends React.PureComponent<Props> {
- handleFilter = (property: string, issue: T.Issue) => {
+ handleFilter = (property: string, issue: TypeIssue) => {
const { onFilterChange } = this.props;
const issuesReset = { issues: [] };
import PageShortcutsTooltip from '../../../components/ui/PageShortcutsTooltip';
import { translate } from '../../../helpers/l10n';
import { isSonarCloud } from '../../../helpers/system';
+import { Paging } from '../../../types/types';
import IssuesCounter from './IssuesCounter';
import TotalEffort from './TotalEffort';
export interface PageActionsProps {
canSetHome: boolean;
effortTotal: number | undefined;
- paging?: T.Paging;
+ paging?: Paging;
selectedIndex?: number;
}
import SelectLegacy from '../../../../components/controls/SelectLegacy';
import { mockIssue } from '../../../../helpers/testMocks';
import { change, waitAndUpdate } from '../../../../helpers/testUtils';
+import { Issue } from '../../../../types/types';
import BulkChangeModal, { MAX_PAGE_SIZE } from '../BulkChangeModal';
jest.mock('../../../../api/issues', () => ({
});
it('should display warning when too many issues are passed', async () => {
- const issues: T.Issue[] = [];
+ const issues: Issue[] = [];
for (let i = MAX_PAGE_SIZE + 1; i > 0; i--) {
issues.push(mockIssue());
}
});
it('should properly handle the search for assignee', async () => {
- const issues: T.Issue[] = [];
+ const issues: Issue[] = [];
for (let i = MAX_PAGE_SIZE + 1; i > 0; i--) {
issues.push(mockIssue());
}
});
});
-const getWrapper = (issues: T.Issue[]) => {
+const getWrapper = (issues: Issue[]) => {
return shallow<BulkChangeModal>(
<BulkChangeModal
component={undefined}
} from '../../../../helpers/testMocks';
import { KEYCODE_MAP, keydown, waitAndUpdate } from '../../../../helpers/testUtils';
import { ComponentQualifier } from '../../../../types/component';
+import { Issue, Paging } from '../../../../types/types';
import {
disableLocationsNavigator,
enableLocationsNavigator,
});
it('should fetch issues until defined', async () => {
- const mockDone = (_: T.Issue[], paging: T.Paging) =>
+ const mockDone = (_: Issue[], paging: Paging) =>
paging.total <= paging.pageIndex * paging.pageSize;
const wrapper = shallowRender({
const instance = wrapper.instance();
await waitAndUpdate(wrapper);
- const updatedIssue: T.Issue = { ...ISSUES[0], type: 'SECURITY_HOTSPOT' };
+ const updatedIssue: Issue = { ...ISSUES[0], type: 'SECURITY_HOTSPOT' };
instance.handleIssueChange(updatedIssue);
expect(wrapper.state().issues).toEqual([updatedIssue, ISSUES[1], ISSUES[2], ISSUES[3]]);
expect(fetchBranchStatus).toBeCalledWith(branchLike, component.key);
wrapper.setState({ openIssue: ISSUES[0] });
- const updatedIssue: T.Issue = { ...ISSUES[0], type: 'SECURITY_HOTSPOT' };
+ const updatedIssue: Issue = { ...ISSUES[0], type: 'SECURITY_HOTSPOT' };
wrapper.instance().handleIssueChange(updatedIssue);
expect(wrapper.state().openIssue).toBe(updatedIssue);
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { Issue } from '../../../types/types';
import ConciseIssueBox from './ConciseIssueBox';
import ConciseIssueComponent from './ConciseIssueComponent';
interface Props {
- issue: T.Issue;
+ issue: Issue;
onFlowSelect: (index: number) => void;
onLocationSelect: (index: number) => void;
onSelect: (issueKey: string) => void;
- previousIssue: T.Issue | undefined;
+ previousIssue: Issue | undefined;
scroll: (element: Element) => void;
selected: boolean;
selectedFlowIndex: number | undefined;
import classNames from 'classnames';
import * as React from 'react';
import TypeHelper from '../../../components/shared/TypeHelper';
+import { Issue } from '../../../types/types';
import ConciseIssueLocations from './ConciseIssueLocations';
import ConciseIssueLocationsNavigator from './ConciseIssueLocationsNavigator';
interface Props {
- issue: T.Issue;
+ issue: Issue;
onClick: (issueKey: string) => void;
onFlowSelect: (index: number) => void;
onLocationSelect: (index: number) => void;
*/
import * as React from 'react';
import { Button } from '../../../components/controls/buttons';
+import { Issue } from '../../../types/types';
import ConciseIssueLocationBadge from './ConciseIssueLocationBadge';
interface Props {
- issue: Pick<T.Issue, 'flows' | 'secondaryLocations'>;
+ issue: Pick<Issue, 'flows' | 'secondaryLocations'>;
onFlowSelect: (index: number) => void;
selectedFlowIndex: number | undefined;
}
*/
import { uniq } from 'lodash';
import * as React from 'react';
+import { Issue } from '../../../types/types';
import { getLocations } from '../utils';
import ConciseIssueLocationsNavigatorLocation from './ConciseIssueLocationsNavigatorLocation';
import CrossFileLocationsNavigator from './CrossFileLocationsNavigator';
interface Props {
- issue: Pick<T.Issue, 'component' | 'key' | 'flows' | 'secondaryLocations' | 'type'>;
+ issue: Pick<Issue, 'component' | 'key' | 'flows' | 'secondaryLocations' | 'type'>;
onLocationSelect: (index: number) => void;
scroll: (element: Element) => void;
selectedFlowIndex: number | undefined;
*/
import * as React from 'react';
import { scrollToElement } from '../../../helpers/scrolling';
+import { Issue } from '../../../types/types';
import ConciseIssue from './ConciseIssue';
interface Props {
- issues: T.Issue[];
+ issues: Issue[];
onFlowSelect: (index: number) => void;
onIssueSelect: (issueKey: string) => void;
onLocationSelect: (index: number) => void;
import * as React from 'react';
import { translateWithParameters } from '../../../helpers/l10n';
import { collapsePath } from '../../../helpers/path';
+import { FlowLocation, Issue } from '../../../types/types';
import ConciseIssueLocationsNavigatorLocation from './ConciseIssueLocationsNavigatorLocation';
interface Props {
- issue: Pick<T.Issue, 'key' | 'type'>;
- locations: T.FlowLocation[];
+ issue: Pick<Issue, 'key' | 'type'>;
+ locations: FlowLocation[];
onLocationSelect: (index: number) => void;
scroll: (element: Element) => void;
selectedLocationIndex: number | undefined;
component: string | undefined;
componentName: string | undefined;
firstLocationIndex: number;
- locations: T.FlowLocation[];
+ locations: FlowLocation[];
}
const MAX_PATH_LENGTH = 15;
this.setState({ collapsed: false });
};
- groupByFile = (locations: T.FlowLocation[]) => {
+ groupByFile = (locations: FlowLocation[]) => {
const groups: LocationGroup[] = [];
- let currentLocations: T.FlowLocation[] = [];
+ let currentLocations: FlowLocation[] = [];
let currentComponent: string | undefined;
let currentComponentName: string | undefined;
let currentFirstLocationIndex = 0;
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { Issue } from '../../../../types/types';
import ConciseIssue from '../ConciseIssue';
-const issue: T.Issue = {
+const issue: Issue = {
actions: [],
component: '',
componentLongName: 'src/file.js',
import { shallow } from 'enzyme';
import * as React from 'react';
import { mockIssue } from '../../../../helpers/testMocks';
+import { FlowLocation } from '../../../../types/types';
import ConciseIssueLocationsNavigator from '../ConciseIssueLocationsNavigator';
-const location1: T.FlowLocation = {
+const location1: FlowLocation = {
component: 'foo',
componentName: 'src/foo.js',
msg: 'Do not use foo',
textRange: { startLine: 7, endLine: 7, startOffset: 5, endOffset: 8 }
};
-const location2: T.FlowLocation = {
+const location2: FlowLocation = {
component: 'foo',
componentName: 'src/foo.js',
msg: 'Do not use foo',
textRange: { startLine: 8, endLine: 8, startOffset: 0, endOffset: 5 }
};
-const location3: T.FlowLocation = {
+const location3: FlowLocation = {
component: 'bar',
componentName: 'src/bar.js',
msg: 'Do not use bar',
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { Issue } from '../../../../types/types';
import ConciseIssuesList from '../ConciseIssuesList';
it('should render', () => {
- const issues = [{ key: 'foo' }, { key: 'bar' }] as T.Issue[];
+ const issues = [{ key: 'foo' }, { key: 'bar' }] as Issue[];
expect(
shallow(
<ConciseIssuesList
import * as React from 'react';
import { mockFlowLocation } from '../../../../helpers/testMocks';
import { click } from '../../../../helpers/testUtils';
+import { FlowLocation } from '../../../../types/types';
import CrossFileLocationsNavigator from '../CrossFileLocationsNavigator';
-const location1: T.FlowLocation = {
+const location1: FlowLocation = {
component: 'foo',
componentName: 'src/foo.js',
msg: 'Do not use foo',
textRange: { startLine: 7, endLine: 7, startOffset: 5, endOffset: 8 }
};
-const location2: T.FlowLocation = {
+const location2: FlowLocation = {
component: 'foo',
componentName: 'src/foo.js',
msg: 'Do not use foo',
textRange: { startLine: 8, endLine: 8, startOffset: 0, endOffset: 5 }
};
-const location3: T.FlowLocation = {
+const location3: FlowLocation = {
component: 'bar',
componentName: 'src/bar.js',
msg: 'Do not use bar',
import SourceViewerHeaderSlim from '../../../components/SourceViewer/SourceViewerHeaderSlim';
import { getBranchLikeQuery } from '../../../helpers/branch-like';
import { BranchLike } from '../../../types/branch-like';
+import {
+ Dict,
+ Duplication,
+ ExpandDirection,
+ FlowLocation,
+ Issue as TypeIssue,
+ IssuesByLine,
+ LinearIssueLocation,
+ Snippet,
+ SnippetGroup,
+ SourceLine,
+ SourceViewerFile
+} from '../../../types/types';
import SnippetViewer from './SnippetViewer';
import {
createSnippets,
interface Props {
branchLike: BranchLike | undefined;
- duplications?: T.Duplication[];
+ duplications?: Duplication[];
duplicationsByLine?: { [line: number]: number[] };
highlightedLocationMessage: { index: number; text: string | undefined } | undefined;
isLastOccurenceOfPrimaryComponent: boolean;
- issue: T.Issue;
+ issue: TypeIssue;
issuePopup?: { issue: string; name: string };
- issuesByLine: T.IssuesByLine;
+ issuesByLine: IssuesByLine;
lastSnippetGroup: boolean;
- loadDuplications: (component: string, line: T.SourceLine) => void;
- locations: T.FlowLocation[];
- onIssueChange: (issue: T.Issue) => void;
+ loadDuplications: (component: string, line: SourceLine) => void;
+ locations: FlowLocation[];
+ onIssueChange: (issue: TypeIssue) => void;
onIssuePopupToggle: (issue: string, popupName: string, open?: boolean) => void;
onLocationSelect: (index: number) => void;
renderDuplicationPopup: (
- component: T.SourceViewerFile,
+ component: SourceViewerFile,
index: number,
line: number
) => React.ReactNode;
scroll?: (element: HTMLElement, offset: number) => void;
- snippetGroup: T.SnippetGroup;
+ snippetGroup: SnippetGroup;
}
interface State {
- additionalLines: { [line: number]: T.SourceLine };
+ additionalLines: { [line: number]: SourceLine };
highlightedSymbols: string[];
loading: boolean;
- openIssuesByLine: T.Dict<boolean>;
- snippets: T.Snippet[];
+ openIssuesByLine: Dict<boolean>;
+ snippets: Snippet[];
}
export default class ComponentSourceSnippetGroupViewer extends React.PureComponent<Props, State> {
}
}
- expandBlock = (snippetIndex: number, direction: T.ExpandDirection): Promise<void> => {
+ expandBlock = (snippetIndex: number, direction: ExpandDirection): Promise<void> => {
const { branchLike, snippetGroup } = this.props;
const { key } = snippetGroup.component;
const { snippets } = this.state;
...getBranchLikeQuery(branchLike)
})
.then(lines =>
- lines.reduce((lineMap: T.Dict<T.SourceLine>, line) => {
+ lines.reduce((lineMap: Dict<SourceLine>, line) => {
line.coverageStatus = getCoverageStatus(line);
lineMap[line.line] = line;
return lineMap;
animateBlockExpansion(
snippetIndex: number,
- direction: T.ExpandDirection,
- newLinesMapped: T.Dict<T.SourceLine>
+ direction: ExpandDirection,
+ newLinesMapped: Dict<SourceLine>
): Promise<void> {
if (this.mounted) {
const { snippets } = this.state;
);
};
- handleOpenIssues = (line: T.SourceLine) => {
+ handleOpenIssues = (line: SourceLine) => {
this.setState(state => ({
openIssuesByLine: { ...state.openIssuesByLine, [line.line]: true }
}));
};
- handleCloseIssues = (line: T.SourceLine) => {
+ handleCloseIssues = (line: SourceLine) => {
this.setState(state => ({
openIssuesByLine: { ...state.openIssuesByLine, [line.line]: false }
}));
});
};
- loadDuplications = (line: T.SourceLine) => {
+ loadDuplications = (line: SourceLine) => {
this.props.loadDuplications(this.props.snippetGroup.component.key, line);
};
snippet
}: {
index: number;
- issuesByLine: T.IssuesByLine;
+ issuesByLine: IssuesByLine;
lastSnippetOfLastGroup: boolean;
- locationsByLine: { [line: number]: T.LinearIssueLocation[] };
- snippet: T.SourceLine[];
+ locationsByLine: { [line: number]: LinearIssueLocation[] };
+ snippet: SourceLine[];
}) {
return (
<SnippetViewer
import { getBranchLikeQuery } from '../../../helpers/branch-like';
import { translate } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
+import {
+ Dict,
+ DuplicatedFile,
+ Duplication,
+ FlowLocation,
+ Issue,
+ SnippetsByComponent,
+ SourceViewerFile
+} from '../../../types/types';
import ComponentSourceSnippetGroupViewer from './ComponentSourceSnippetGroupViewer';
import { groupLocationsByComponent } from './utils';
interface Props {
branchLike: BranchLike | undefined;
highlightedLocationMessage?: { index: number; text: string | undefined };
- issue: T.Issue;
- issues: T.Issue[];
- locations: T.FlowLocation[];
- onIssueChange: (issue: T.Issue) => void;
+ issue: Issue;
+ issues: Issue[];
+ locations: FlowLocation[];
+ onIssueChange: (issue: Issue) => void;
onLoaded?: () => void;
onLocationSelect: (index: number) => void;
scroll?: (element: HTMLElement) => void;
}
interface State {
- components: T.Dict<T.SnippetsByComponent>;
- duplicatedFiles?: T.Dict<T.DuplicatedFile>;
- duplications?: T.Duplication[];
+ components: Dict<SnippetsByComponent>;
+ duplicatedFiles?: Dict<DuplicatedFile>;
+ duplications?: Duplication[];
duplicationsByLine: { [line: number]: number[] };
issuePopup?: { issue: string; name: string };
loading: boolean;
});
};
- renderDuplicationPopup = (component: T.SourceViewerFile, index: number, line: number) => {
+ renderDuplicationPopup = (component: SourceViewerFile, index: number, line: number) => {
const { duplicatedFiles, duplications } = this.state;
if (!component || !duplicatedFiles) {
import { translate } from '../../../helpers/l10n';
import { scrollHorizontally } from '../../../helpers/scrolling';
import { BranchLike } from '../../../types/branch-like';
+import {
+ Dict,
+ Duplication,
+ ExpandDirection,
+ FlowLocation,
+ Issue,
+ IssuesByLine,
+ LinearIssueLocation,
+ SourceLine,
+ SourceViewerFile
+} from '../../../types/types';
import './SnippetViewer.css';
import { inSnippet, LINES_BELOW_ISSUE } from './utils';
interface Props {
branchLike: BranchLike | undefined;
- component: T.SourceViewerFile;
+ component: SourceViewerFile;
displayLineNumberOptions?: boolean;
displaySCM?: boolean;
- duplications?: T.Duplication[];
+ duplications?: Duplication[];
duplicationsByLine?: { [line: number]: number[] };
- expandBlock: (snippetIndex: number, direction: T.ExpandDirection) => Promise<void>;
- handleCloseIssues: (line: T.SourceLine) => void;
- handleOpenIssues: (line: T.SourceLine) => void;
+ expandBlock: (snippetIndex: number, direction: ExpandDirection) => Promise<void>;
+ handleCloseIssues: (line: SourceLine) => void;
+ handleOpenIssues: (line: SourceLine) => void;
handleSymbolClick: (symbols: string[]) => void;
highlightedLocationMessage: { index: number; text: string | undefined } | undefined;
highlightedSymbols: string[];
index: number;
- issue: Pick<T.Issue, 'key' | 'textRange' | 'line'>;
+ issue: Pick<Issue, 'key' | 'textRange' | 'line'>;
issuePopup?: { issue: string; name: string };
- issuesByLine: T.IssuesByLine;
+ issuesByLine: IssuesByLine;
lastSnippetOfLastGroup: boolean;
- loadDuplications?: (line: T.SourceLine) => void;
- locations: T.FlowLocation[];
- locationsByLine: { [line: number]: T.LinearIssueLocation[] };
- onIssueChange: (issue: T.Issue) => void;
+ loadDuplications?: (line: SourceLine) => void;
+ locations: FlowLocation[];
+ locationsByLine: { [line: number]: LinearIssueLocation[] };
+ onIssueChange: (issue: Issue) => void;
onIssuePopupToggle: (issue: string, popupName: string, open?: boolean) => void;
onLocationSelect: (index: number) => void;
- openIssuesByLine: T.Dict<boolean>;
+ openIssuesByLine: Dict<boolean>;
renderDuplicationPopup: (index: number, line: number) => React.ReactNode;
scroll?: (element: HTMLElement, offset?: number) => void;
- snippet: T.SourceLine[];
+ snippet: SourceLine[];
}
export default class SnippetViewer extends React.PureComponent<Props> {
}
};
- expandBlock = (direction: T.ExpandDirection) => () =>
+ expandBlock = (direction: ExpandDirection) => () =>
this.props.expandBlock(this.props.index, direction).then(() => {
if (direction === 'down') {
this.scrollToLastExpandedRow();
displayDuplications: boolean;
displaySCM?: boolean;
index: number;
- issuesForLine: T.Issue[];
- issueLocations: T.LinearIssueLocation[];
- line: T.SourceLine;
- snippet: T.SourceLine[];
+ issuesForLine: Issue[];
+ issueLocations: LinearIssueLocation[];
+ line: SourceLine;
+ snippet: SourceLine[];
symbols: string[];
verticalBuffer: number;
}) {
mockSourceViewerFile
} from '../../../../helpers/testMocks';
import { waitAndUpdate } from '../../../../helpers/testUtils';
+import { SnippetGroup } from '../../../../types/types';
import ComponentSourceSnippetGroupViewer from '../ComponentSourceSnippetGroupViewer';
import SnippetViewer from '../SnippetViewer';
textRange: { startLine: 7, endLine: 7, startOffset: 5, endOffset: 10 }
});
- const snippetGroup: T.SnippetGroup = {
+ const snippetGroup: SnippetGroup = {
locations: [
mockFlowLocation({
component: issue.component,
textRange: { startLine: 7, endLine: 7, startOffset: 5, endOffset: 10 }
});
- const snippetGroup: T.SnippetGroup = {
+ const snippetGroup: SnippetGroup = {
locations: [
mockFlowLocation({
component: issue.component,
const issue = mockIssue(true, {
textRange: { startLine: 74, endLine: 74, startOffset: 5, endOffset: 10 }
});
- const snippetGroup: T.SnippetGroup = {
+ const snippetGroup: SnippetGroup = {
locations: [
mockFlowLocation({
component: 'a',
(getSources as jest.Mock).mockResolvedValueOnce(
Object.values(mockSnippetsByComponent('a', times(14)).sources)
);
- const snippetGroup: T.SnippetGroup = {
+ const snippetGroup: SnippetGroup = {
locations: [
mockFlowLocation({
component: 'a',
mockSnippetsByComponent('a', [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]).sources
)
);
- const snippetGroup: T.SnippetGroup = {
+ const snippetGroup: SnippetGroup = {
locations: [mockFlowLocation()],
...mockSnippetsByComponent('a', [1, 2, 3, 4, 5, 6, 7])
};
});
it('should correctly handle lines actions', () => {
- const snippetGroup: T.SnippetGroup = {
+ const snippetGroup: SnippetGroup = {
locations: [
mockFlowLocation({
component: 'a',
});
describe('getNodes', () => {
- const snippetGroup: T.SnippetGroup = {
+ const snippetGroup: SnippetGroup = {
component: mockSourceViewerFile(),
locations: [],
sources: []
describe('getHeight', () => {
jest.useFakeTimers();
- const snippetGroup: T.SnippetGroup = {
+ const snippetGroup: SnippetGroup = {
component: mockSourceViewerFile(),
locations: [],
sources: []
});
function shallowRender(props: Partial<ComponentSourceSnippetGroupViewer['props']> = {}) {
- const snippetGroup: T.SnippetGroup = {
+ const snippetGroup: SnippetGroup = {
component: mockSourceViewerFile(),
locations: [],
sources: []
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+import {
+ ExpandDirection,
+ FlowLocation,
+ Issue,
+ LineMap,
+ Snippet,
+ SnippetGroup,
+ SnippetsByComponent,
+ SourceLine
+} from '../../../types/types';
+
const LINES_ABOVE = 5;
const LINES_BELOW = 5;
export const MERGE_DISTANCE = 11; // Merge if snippets are eleven lines away (separated by 10 lines) or fewer
export const LINES_BELOW_ISSUE = 9;
export const EXPAND_BY_LINES = 50;
-function unknownComponent(key: string): T.SnippetsByComponent {
+function unknownComponent(key: string): SnippetsByComponent {
return {
component: {
key,
return !(startA > endB + MERGE_DISTANCE || endA < startB - MERGE_DISTANCE);
}
-export function getPrimaryLocation(issue: T.Issue): T.FlowLocation {
+export function getPrimaryLocation(issue: Issue): FlowLocation {
return {
component: issue.component,
textRange: issue.textRange || {
};
}
-function addLinesBellow(params: { issue: T.Issue; locationEnd: number }) {
+function addLinesBellow(params: { issue: Issue; locationEnd: number }) {
const { issue, locationEnd } = params;
const issueEndLine = (issue.textRange && issue.textRange.endLine) || 0;
export function createSnippets(params: {
component: string;
- issue: T.Issue;
- locations: T.FlowLocation[];
-}): T.Snippet[] {
+ issue: Issue;
+ locations: FlowLocation[];
+}): Snippet[] {
const { component, issue, locations } = params;
const hasSecondaryLocations = issue.secondaryLocations.length > 0;
// For each location: compute its range, and then compare with other ranges
// to merge snippets that collide.
const ranges = (addIssueLocation ? [getPrimaryLocation(issue), ...locations] : locations).reduce(
- (snippets: T.Snippet[], loc, index) => {
+ (snippets: Snippet[], loc, index) => {
const startIndex = Math.max(1, loc.textRange.startLine - LINES_ABOVE);
const endIndex = addLinesBellow({ issue, locationEnd: loc.textRange.endLine });
return hasSecondaryLocations ? ranges.sort((a, b) => a.start - b.start) : ranges;
}
-export function linesForSnippets(snippets: T.Snippet[], componentLines: T.LineMap) {
+export function linesForSnippets(snippets: Snippet[], componentLines: LineMap) {
return snippets
.map(snippet => {
const lines = [];
}
export function groupLocationsByComponent(
- issue: T.Issue,
- locations: T.FlowLocation[],
- components: { [key: string]: T.SnippetsByComponent }
+ issue: Issue,
+ locations: FlowLocation[],
+ components: { [key: string]: SnippetsByComponent }
) {
let currentComponent = '';
- let currentGroup: T.SnippetGroup;
- const groups: T.SnippetGroup[] = [];
+ let currentGroup: SnippetGroup;
+ const groups: SnippetGroup[] = [];
const addGroup = (componentKey: string) => {
currentGroup = {
snippetIndex,
snippets
}: {
- direction: T.ExpandDirection;
+ direction: ExpandDirection;
snippetIndex: number;
- snippets: T.Snippet[];
+ snippets: Snippet[];
}) {
const snippetToExpand = snippets.find(s => s.index === snippetIndex);
if (!snippetToExpand) {
});
}
-export function inSnippet(line: number, snippet: T.SourceLine[]) {
+export function inSnippet(line: number, snippet: SourceLine[]) {
return line >= snippet[0].line && line <= snippet[snippet.length - 1].line;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { Location } from '../../helpers/urls';
+import { RawQuery } from '../../types/types';
import { areMyIssuesSelected, parseQuery, serializeQuery } from './utils';
function parseHash(hash: string) {
- const query: T.RawQuery = {};
+ const query: RawQuery = {};
const parts = hash.split('|');
parts.forEach(part => {
const tokens = part.split('=');
import { highlightTerm } from '../../../helpers/search';
import { isUserActive } from '../../../helpers/users';
import { Facet } from '../../../types/issues';
+import { Dict, UserBase } from '../../../types/types';
import { Query, searchAssignees } from '../utils';
interface Props {
onToggle: (property: string) => void;
open: boolean;
query: Query;
- stats: T.Dict<number> | undefined;
- referencedUsers: T.Dict<T.UserBase>;
+ stats: Dict<number> | undefined;
+ referencedUsers: Dict<UserBase>;
}
export default class AssigneeFacet extends React.PureComponent<Props> {
}
};
- loadSearchResultCount = (assignees: T.UserBase[]) => {
+ loadSearchResultCount = (assignees: UserBase[]) => {
return this.props.loadSearchResultCount('assignees', {
assigned: undefined,
assignees: assignees.map(assignee => assignee.login)
);
};
- renderSearchResult = (result: T.UserBase, query: string) => {
+ renderSearchResult = (result: UserBase, query: string) => {
const displayName = isUserActive(result)
? result.name
: translateWithParameters('user.x_deleted', result.login);
}
return (
- <ListStyleFacet<T.UserBase>
+ <ListStyleFacet<UserBase>
facetHeader={translate('issues.facet.assignees')}
fetching={this.props.fetching}
getFacetItemText={this.getAssigneeName}
import { translate } from '../../../helpers/l10n';
import { highlightTerm } from '../../../helpers/search';
import { Facet } from '../../../types/issues';
+import { Component, Dict } from '../../../types/types';
import { Query } from '../utils';
interface Props {
- component: T.Component | undefined;
+ component: Component | undefined;
fetching: boolean;
loadSearchResultCount: (property: string, changes: Partial<Query>) => Promise<Facet>;
onChange: (changes: Partial<Query>) => void;
onToggle: (property: string) => void;
open: boolean;
query: Query;
- stats: T.Dict<number> | undefined;
+ stats: Dict<number> | undefined;
author: string[];
}
import { translate } from '../../../helpers/l10n';
import { formatMeasure } from '../../../helpers/measures';
import { isPortfolioLike } from '../../../types/component';
+import { Component, Dict } from '../../../types/types';
import { Query } from '../utils';
interface Props {
- component: T.Component | undefined;
+ component: Component | undefined;
createdAfter: Date | undefined;
createdAfterIncludesTime: boolean;
createdAt: string;
onToggle: (property: string) => void;
open: boolean;
sinceLeakPeriod: boolean;
- stats: T.Dict<number> | undefined;
+ stats: Dict<number> | undefined;
}
export class CreationDateFacet extends React.PureComponent<Props & WrappedComponentProps> {
import { highlightTerm } from '../../../helpers/search';
import { getLanguages, Store } from '../../../store/rootReducer';
import { Facet, ReferencedLanguage } from '../../../types/issues';
+import { Dict } from '../../../types/types';
import { Query } from '../utils';
interface InstalledLanguage {
onToggle: (property: string) => void;
open: boolean;
query: Query;
- referencedLanguages: T.Dict<ReferencedLanguage>;
- stats: T.Dict<number> | undefined;
+ referencedLanguages: Dict<ReferencedLanguage>;
+ stats: Dict<number> | undefined;
}
class LanguageFacet extends React.PureComponent<Props> {
import { highlightTerm } from '../../../helpers/search';
import { ComponentQualifier } from '../../../types/component';
import { Facet, ReferencedComponent } from '../../../types/issues';
+import { Component, Dict, Paging } from '../../../types/types';
import { Query } from '../utils';
interface Props {
- component: T.Component | undefined;
+ component: Component | undefined;
loadSearchResultCount: (property: string, changes: Partial<Query>) => Promise<Facet>;
fetching: boolean;
onChange: (changes: Partial<Query>) => void;
open: boolean;
projects: string[];
query: Query;
- referencedComponents: T.Dict<ReferencedComponent>;
- stats: T.Dict<number> | undefined;
+ referencedComponents: Dict<ReferencedComponent>;
+ stats: Dict<number> | undefined;
}
interface SearchedProject {
handleSearch = (
query: string,
page = 1
- ): Promise<{ results: SearchedProject[]; paging: T.Paging }> => {
+ ): Promise<{ results: SearchedProject[]; paging: Paging }> => {
const { component } = this.props;
if (
component &&
import FacetItemsList from '../../../components/facet/FacetItemsList';
import MultipleSelectionHint from '../../../components/facet/MultipleSelectionHint';
import { translate } from '../../../helpers/l10n';
+import { Dict } from '../../../types/types';
import { formatFacetStat, Query } from '../utils';
interface Props {
open: boolean;
resolved: boolean;
resolutions: string[];
- stats: T.Dict<number> | undefined;
+ stats: Dict<number> | undefined;
}
const RESOLUTIONS = ['', 'FALSE-POSITIVE', 'FIXED', 'REMOVED', 'WONTFIX'];
import ListStyleFacet from '../../../components/facet/ListStyleFacet';
import { translate } from '../../../helpers/l10n';
import { Facet, ReferencedRule } from '../../../types/issues';
+import { Dict, Rule } from '../../../types/types';
import { Query } from '../utils';
interface Props {
onToggle: (property: string) => void;
open: boolean;
query: Query;
- referencedRules: T.Dict<ReferencedRule>;
+ referencedRules: Dict<ReferencedRule>;
rules: string[];
- stats: T.Dict<number> | undefined;
+ stats: Dict<number> | undefined;
}
export default class RuleFacet extends React.PureComponent<Props> {
}));
};
- loadSearchResultCount = (rules: T.Rule[]) => {
+ loadSearchResultCount = (rules: Rule[]) => {
return this.props.loadSearchResultCount('rules', { rules: rules.map(rule => rule.key) });
};
return langName ? `(${langName}) ${name}` : name;
};
- renderSearchResult = (rule: T.Rule) => {
+ renderSearchResult = (rule: Rule) => {
return this.formatRuleName(rule.name, rule.langName);
};
render() {
return (
- <ListStyleFacet<T.Rule>
+ <ListStyleFacet<Rule>
facetHeader={translate('issues.facet.rules')}
fetching={this.props.fetching}
getFacetItemText={this.getRuleName}
import QualifierIcon from '../../../components/icons/QualifierIcon';
import { SOURCE_SCOPES } from '../../../helpers/constants';
import { translate } from '../../../helpers/l10n';
+import { Dict } from '../../../types/types';
import { formatFacetStat, Query } from '../utils';
export interface ScopeFacetProps {
onToggle: (property: string) => void;
open: boolean;
scopes: string[];
- stats: T.Dict<number> | undefined;
+ stats: Dict<number> | undefined;
}
export default function ScopeFacet(props: ScopeFacetProps) {
import MultipleSelectionHint from '../../../components/facet/MultipleSelectionHint';
import SeverityHelper from '../../../components/shared/SeverityHelper';
import { translate } from '../../../helpers/l10n';
+import { Dict } from '../../../types/types';
import { formatFacetStat, Query } from '../utils';
interface Props {
onToggle: (property: string) => void;
open: boolean;
severities: string[];
- stats: T.Dict<number> | undefined;
+ stats: Dict<number> | undefined;
}
const SEVERITIES = ['BLOCKER', 'MINOR', 'CRITICAL', 'INFO', 'MAJOR'];
*/
import * as React from 'react';
import { connect } from 'react-redux';
+import { isBranch, isPullRequest } from '../../../helpers/branch-like';
import { getGlobalSettingValue, Store } from '../../../store/rootReducer';
import { BranchLike } from '../../../types/branch-like';
-import { isBranch, isPullRequest } from '../../../helpers/branch-like';
import { ComponentQualifier, isApplication, isPortfolioLike } from '../../../types/component';
import {
Facet,
ReferencedLanguage,
ReferencedRule
} from '../../../types/issues';
+import { Component, Dict, UserBase } from '../../../types/types';
import { Query } from '../utils';
import AssigneeFacet from './AssigneeFacet';
import AuthorFacet from './AuthorFacet';
export interface Props {
branchLike?: BranchLike;
- component: T.Component | undefined;
+ component: Component | undefined;
createdAfterIncludesTime: boolean;
- facets: T.Dict<Facet | undefined>;
+ facets: Dict<Facet | undefined>;
loadSearchResultCount: (property: string, changes: Partial<Query>) => Promise<Facet>;
- loadingFacets: T.Dict<boolean>;
+ loadingFacets: Dict<boolean>;
myIssues: boolean;
onFacetToggle: (property: string) => void;
onFilterChange: (changes: Partial<Query>) => void;
- openFacets: T.Dict<boolean>;
+ openFacets: Dict<boolean>;
query: Query;
- referencedComponentsById: T.Dict<ReferencedComponent>;
- referencedComponentsByKey: T.Dict<ReferencedComponent>;
- referencedLanguages: T.Dict<ReferencedLanguage>;
- referencedRules: T.Dict<ReferencedRule>;
- referencedUsers: T.Dict<T.UserBase>;
+ referencedComponentsById: Dict<ReferencedComponent>;
+ referencedComponentsByKey: Dict<ReferencedComponent>;
+ referencedLanguages: Dict<ReferencedLanguage>;
+ referencedRules: Dict<ReferencedRule>;
+ referencedUsers: Dict<UserBase>;
disableDeveloperAggregatedInfo: boolean;
}
} from '../../../helpers/security-standard';
import { Facet } from '../../../types/issues';
import { SecurityStandard, Standards, StandardType } from '../../../types/security';
+import { Dict } from '../../../types/types';
import { formatFacetStat, Query, STANDARDS } from '../utils';
interface Props {
cwe: string[];
cweOpen: boolean;
- cweStats: T.Dict<number> | undefined;
+ cweStats: Dict<number> | undefined;
fetchingCwe: boolean;
fetchingOwaspTop10: boolean;
fetchingSansTop25: boolean;
open: boolean;
owaspTop10: string[];
owaspTop10Open: boolean;
- owaspTop10Stats: T.Dict<number> | undefined;
+ owaspTop10Stats: Dict<number> | undefined;
query: Partial<Query>;
sansTop25: string[];
sansTop25Open: boolean;
- sansTop25Stats: T.Dict<number> | undefined;
+ sansTop25Stats: Dict<number> | undefined;
sonarsourceSecurity: string[];
sonarsourceSecurityOpen: boolean;
- sonarsourceSecurityStats: T.Dict<number> | undefined;
+ sonarsourceSecurityStats: Dict<number> | undefined;
}
interface State {
import MultipleSelectionHint from '../../../components/facet/MultipleSelectionHint';
import StatusHelper from '../../../components/shared/StatusHelper';
import { translate } from '../../../helpers/l10n';
+import { Dict } from '../../../types/types';
import { formatFacetStat, Query } from '../utils';
interface Props {
onChange: (changes: Partial<Query>) => void;
onToggle: (property: string) => void;
open: boolean;
- stats: T.Dict<number> | undefined;
+ stats: Dict<number> | undefined;
statuses: string[];
}
import { translate } from '../../../helpers/l10n';
import { highlightTerm } from '../../../helpers/search';
import { Facet } from '../../../types/issues';
+import { Component, Dict } from '../../../types/types';
import { Query } from '../utils';
interface Props {
- component: T.Component | undefined;
+ component: Component | undefined;
branch?: string;
fetching: boolean;
loadSearchResultCount: (property: string, changes: Partial<Query>) => Promise<Facet>;
onToggle: (property: string) => void;
open: boolean;
query: Query;
- stats: T.Dict<number> | undefined;
+ stats: Dict<number> | undefined;
tags: string[];
}
import IssueTypeIcon from '../../../components/icons/IssueTypeIcon';
import { ISSUE_TYPES } from '../../../helpers/constants';
import { translate } from '../../../helpers/l10n';
+import { Dict } from '../../../types/types';
import { formatFacetStat, Query } from '../utils';
interface Props {
onChange: (changes: Partial<Query>) => void;
onToggle: (property: string) => void;
open: boolean;
- stats: T.Dict<number> | undefined;
+ stats: Dict<number> | undefined;
types: string[];
}
import { isDefined } from '../../helpers/types';
import { Facet, RawFacet } from '../../types/issues';
import { SecurityStandard, StandardType } from '../../types/security';
+import { Dict, Issue, Paging, RawQuery, UserBase } from '../../types/types';
export interface Query {
assigned: boolean;
const parseAsSort = (sort: string) => (sort === 'CREATION_DATE' ? 'CREATION_DATE' : '');
const ISSUES_DEFAULT = 'sonarqube.issues.default';
-export function parseQuery(query: T.RawQuery): Query {
+export function parseQuery(query: RawQuery): Query {
return {
assigned: parseAsBoolean(query.assigned),
assignees: parseAsArray(query.assignees, parseAsString),
};
}
-export function getOpen(query: T.RawQuery): string | undefined {
+export function getOpen(query: RawQuery): string | undefined {
return query.open;
}
-export const areMyIssuesSelected = (query: T.RawQuery) => query.myIssues === 'true';
+export const areMyIssuesSelected = (query: RawQuery) => query.myIssues === 'true';
-export function serializeQuery(query: Query): T.RawQuery {
+export function serializeQuery(query: Query): RawQuery {
const filter = {
assigned: query.assigned ? undefined : 'false',
assignees: serializeStringArray(query.assignees),
return cleanQuery(filter);
}
-export const areQueriesEqual = (a: T.RawQuery, b: T.RawQuery) =>
+export const areQueriesEqual = (a: RawQuery, b: RawQuery) =>
queriesEqual(parseQuery(a), parseQuery(b));
-export function parseFacets(facets: RawFacet[]): T.Dict<Facet> {
+export function parseFacets(facets: RawFacet[]): Dict<Facet> {
if (!facets) {
return {};
}
- const result: T.Dict<Facet> = {};
+ const result: Dict<Facet> = {};
facets.forEach(facet => {
const values: Facet = {};
facet.values.forEach(value => {
export const searchAssignees = (
query: string,
page = 1
-): Promise<{ paging: T.Paging; results: T.UserBase[] }> => {
+): Promise<{ paging: Paging; results: UserBase[] }> => {
return searchUsers({ p: page, q: query }).then(({ paging, users }) => ({
paging,
results: users
save(ISSUES_DEFAULT, myIssues ? LOCALSTORAGE_MY : LOCALSTORAGE_ALL);
export function getLocations(
- { flows, secondaryLocations }: Pick<T.Issue, 'flows' | 'secondaryLocations'>,
+ { flows, secondaryLocations }: Pick<Issue, 'flows' | 'secondaryLocations'>,
selectedFlowIndex: number | undefined
) {
if (selectedFlowIndex !== undefined) {
}
export function getSelectedLocation(
- issue: Pick<T.Issue, 'flows' | 'secondaryLocations'>,
+ issue: Pick<Issue, 'flows' | 'secondaryLocations'>,
selectedFlowIndex: number | undefined,
selectedLocationIndex: number | undefined
) {
}
export function allLocationsEmpty(
- issue: Pick<T.Issue, 'flows' | 'secondaryLocations'>,
+ issue: Pick<Issue, 'flows' | 'secondaryLocations'>,
selectedFlowIndex: number | undefined
) {
return getLocations(issue, selectedFlowIndex).every(location => !location.msg);
}
export function shouldOpenStandardsFacet(
- openFacets: T.Dict<boolean>,
+ openFacets: Dict<boolean>,
query: Partial<Query>
): boolean {
return (
}
export function shouldOpenStandardsChildFacet(
- openFacets: T.Dict<boolean>,
+ openFacets: Dict<boolean>,
query: Partial<Query>,
standardType: SecurityStandard
): boolean {
}
export function shouldOpenSonarSourceSecurityFacet(
- openFacets: T.Dict<boolean>,
+ openFacets: Dict<boolean>,
query: Partial<Query>
): boolean {
// Open it by default if the parent is open, and no other standard is open.
return query.types !== undefined && query.types.includes('VULNERABILITY');
}
-function isOneStandardChildFacetOpen(openFacets: T.Dict<boolean>, query: Partial<Query>): boolean {
+function isOneStandardChildFacetOpen(openFacets: Dict<boolean>, query: Partial<Query>): boolean {
return STANDARD_TYPES.some(standardType =>
shouldOpenStandardsChildFacet(openFacets, query, standardType)
);
import AdminContext from '../../app/components/AdminContext';
import { getAppState, getGlobalSettingValue, Store } from '../../store/rootReducer';
import { EditionKey } from '../../types/editions';
+import { RawQuery } from '../../types/types';
import App from './App';
interface OwnProps {
- location: { pathname: string; query: T.RawQuery };
+ location: { pathname: string; query: RawQuery };
}
interface StateToProps {
import { memoize } from 'lodash';
import { cleanQuery, parseAsString, serializeString } from '../../helpers/query';
import { Plugin } from '../../types/plugins';
+import { RawQuery } from '../../types/types';
export interface Query {
filter: string;
export const DEFAULT_FILTER = 'all';
export const parseQuery = memoize(
- (urlQuery: T.RawQuery): Query => ({
+ (urlQuery: RawQuery): Query => ({
filter: parseAsString(urlQuery['filter']) || DEFAULT_FILTER,
search: parseAsString(urlQuery['search'])
})
);
export const serializeQuery = memoize(
- (query: Query): T.RawQuery =>
+ (query: Query): RawQuery =>
cleanQuery({
filter: query.filter === DEFAULT_FILTER ? undefined : serializeString(query.filter),
search: query.search ? serializeString(query.search) : undefined
import { translate } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
import { GraphType, MeasureHistory } from '../../../types/project-activity';
+import { Analysis as AnalysisType, Component, Metric } from '../../../types/types';
import Analysis from './Analysis';
export interface ActivityPanelProps {
- analyses?: T.Analysis[];
+ analyses?: AnalysisType[];
branchLike?: BranchLike;
- component: Pick<T.Component, 'key' | 'qualifier'>;
+ component: Pick<Component, 'key' | 'qualifier'>;
graph?: GraphType;
leakPeriodDate?: Date;
loading?: boolean;
measuresHistory: MeasureHistory[];
- metrics: T.Metric[];
+ metrics: Metric[];
onGraphChange: (graph: GraphType) => void;
}
import DateTimeFormatter from '../../../components/intl/DateTimeFormatter';
import { translate } from '../../../helpers/l10n';
import { ComponentQualifier } from '../../../types/component';
+import { Analysis as TypeAnalysis } from '../../../types/types';
import Event from './Event';
export interface AnalysisProps {
- analysis: T.Analysis;
+ analysis: TypeAnalysis;
qualifier: string;
}
import { MetricKey } from '../../../types/metrics';
import { GraphType, MeasureHistory } from '../../../types/project-activity';
import { QualityGateStatus, QualityGateStatusCondition } from '../../../types/quality-gates';
+import { Analysis, Component, MeasureEnhanced, Metric, Period } from '../../../types/types';
import '../styles.css';
import { HISTORY_METRICS_LIST, METRICS } from '../utils';
import BranchOverviewRenderer from './BranchOverviewRenderer';
interface Props {
branch?: Branch;
branchesEnabled?: boolean;
- component: T.Component;
+ component: Component;
projectBinding?: ProjectAlmBindingResponse;
}
interface State {
- analyses?: T.Analysis[];
+ analyses?: Analysis[];
appLeak?: ApplicationPeriod;
detectedCIOnLastAnalysis?: boolean;
graph: GraphType;
loadingHistory?: boolean;
loadingStatus?: boolean;
- measures?: T.MeasureEnhanced[];
+ measures?: MeasureEnhanced[];
measuresHistory?: MeasureHistory[];
- metrics?: T.Metric[];
- period?: T.Period;
+ metrics?: Metric[];
+ period?: Period;
qgStatuses?: QualityGateStatus[];
}
);
};
- getFailedConditions = (
- conditions: QualityGateStatusCondition[],
- measures: T.MeasureEnhanced[]
- ) => {
+ getFailedConditions = (conditions: QualityGateStatusCondition[], measures: MeasureEnhanced[]) => {
return (
conditions
.filter(c => c.level !== 'OK')
import { ComponentQualifier } from '../../../types/component';
import { GraphType, MeasureHistory } from '../../../types/project-activity';
import { QualityGateStatus } from '../../../types/quality-gates';
+import { Analysis, Component, MeasureEnhanced, Metric, Period } from '../../../types/types';
import ActivityPanel from './ActivityPanel';
import FirstAnalysisNextStepsNotif from './FirstAnalysisNextStepsNotif';
import { MeasuresPanel } from './MeasuresPanel';
import QualityGatePanel from './QualityGatePanel';
export interface BranchOverviewRendererProps {
- analyses?: T.Analysis[];
+ analyses?: Analysis[];
appLeak?: ApplicationPeriod;
branch?: Branch;
branchesEnabled?: boolean;
- component: T.Component;
+ component: Component;
detectedCIOnLastAnalysis?: boolean;
graph?: GraphType;
loadingHistory?: boolean;
loadingStatus?: boolean;
- measures?: T.MeasureEnhanced[];
+ measures?: MeasureEnhanced[];
measuresHistory?: MeasureHistory[];
- metrics?: T.Metric[];
+ metrics?: Metric[];
onGraphChange: (graph: GraphType) => void;
- period?: T.Period;
+ period?: Period;
projectBinding?: ProjectAlmBindingResponse;
projectIsEmpty?: boolean;
qgStatuses?: QualityGateStatus[];
import { findMeasure, formatMeasure, localizeMetric } from '../../../helpers/measures';
import { BranchLike } from '../../../types/branch-like';
import { MetricKey } from '../../../types/metrics';
+import { Component, MeasureEnhanced } from '../../../types/types';
export interface DebtValueProps {
branchLike?: BranchLike;
- component: T.Component;
- measures: T.MeasureEnhanced[];
+ component: Component;
+ measures: MeasureEnhanced[];
useDiffMetric?: boolean;
}
import { findMeasure, formatMeasure } from '../../../helpers/measures';
import { BranchLike } from '../../../types/branch-like';
import { MetricKey } from '../../../types/metrics';
+import { Component, MeasureEnhanced } from '../../../types/types';
export interface DrilldownMeasureValueProps {
branchLike?: BranchLike;
- component: T.Component;
- measures: T.MeasureEnhanced[];
+ component: Component;
+ measures: MeasureEnhanced[];
metric: MetricKey;
}
import { FormattedMessage } from 'react-intl';
import Level from '../../../components/ui/Level';
import { translate } from '../../../helpers/l10n';
+import { AnalysisEvent } from '../../../types/types';
import { isDefinitionChangeEvent } from '../../projectActivity/components/DefinitionChangeEventInner';
import { isRichQualityGateEvent } from '../../projectActivity/components/RichQualityGateEventInner';
interface Props {
- event: T.AnalysisEvent;
+ event: AnalysisEvent;
}
export function Event({ event }: Props) {
import { isLoggedIn } from '../../../helpers/users';
import { ProjectAlmBindingResponse } from '../../../types/alm-settings';
import { ComponentQualifier } from '../../../types/component';
+import { Component, CurrentUser } from '../../../types/types';
import { PULL_REQUEST_DECORATION_BINDING_CATEGORY } from '../../settings/components/AdditionalCategoryKeys';
export interface FirstAnalysisNextStepsNotifProps {
branchesEnabled?: boolean;
- component: T.Component;
- currentUser: T.CurrentUser;
+ component: Component;
+ currentUser: CurrentUser;
detectedCIOnLastAnalysis?: boolean;
projectBinding?: ProjectAlmBindingResponse;
}
import * as React from 'react';
import { isApplicationPeriod } from '../../../helpers/periods';
import { ApplicationPeriod } from '../../../types/application';
+import { Period } from '../../../types/types';
import ApplicationLeakPeriodInfo from './ApplicationLeakPeriodInfo';
import ProjectLeakPeriodInfo from './ProjectLeakPeriodInfo';
export interface LeakPeriodInfoProps {
- leakPeriod: T.Period | ApplicationPeriod;
+ leakPeriod: Period | ApplicationPeriod;
}
export function LeakPeriodInfo({ leakPeriod }: LeakPeriodInfoProps) {
import { ComponentQualifier } from '../../../types/component';
import { IssueType } from '../../../types/issues';
import { MetricKey } from '../../../types/metrics';
+import { Component, MeasureEnhanced, Period } from '../../../types/types';
import MeasurementLabel from '../components/MeasurementLabel';
import { MeasurementType } from '../utils';
import { DrilldownMeasureValue } from './DrilldownMeasureValue';
export interface MeasuresPanelProps {
appLeak?: ApplicationPeriod;
branch?: Branch;
- component: T.Component;
+ component: Component;
loading?: boolean;
- measures?: T.MeasureEnhanced[];
- period?: T.Period;
+ measures?: MeasureEnhanced[];
+ period?: Period;
}
export enum MeasuresPanelTabs {
import { BranchLike } from '../../../types/branch-like';
import { ComponentQualifier } from '../../../types/component';
import { IssueType } from '../../../types/issues';
+import { Component, MeasureEnhanced } from '../../../types/types';
import IssueLabel from '../components/IssueLabel';
import IssueRating from '../components/IssueRating';
import DebtValue from './DebtValue';
export interface MeasuresPanelIssueMeasureRowProps {
branchLike?: BranchLike;
- component: T.Component;
+ component: Component;
isNewCodeTab: boolean;
- measures: T.MeasureEnhanced[];
+ measures: MeasureEnhanced[];
type: IssueType;
}
import { getBaseUrl } from '../../../helpers/system';
import { Branch } from '../../../types/branch-like';
import { ComponentQualifier } from '../../../types/component';
+import { Component, Period } from '../../../types/types';
export interface MeasuresPanelNoNewCodeProps {
branch?: Branch;
- component: T.Component;
- period?: T.Period;
+ component: Component;
+ period?: Period;
}
export default function MeasuresPanelNoNewCode(props: MeasuresPanelNoNewCodeProps) {
import { BranchLike } from '../../../types/branch-like';
import { ComponentQualifier } from '../../../types/component';
import { MetricKey } from '../../../types/metrics';
+import { Component, MeasureEnhanced } from '../../../types/types';
interface Props {
branchLike?: BranchLike;
- component: T.Component;
- measures?: T.MeasureEnhanced[];
+ component: Component;
+ measures?: MeasureEnhanced[];
}
export function NoCodeWarning({ branchLike, component, measures }: Props) {
import { formatterOption } from '../../../components/intl/DateTimeFormatter';
import { translateWithParameters } from '../../../helpers/l10n';
import { getPeriodDate, getPeriodLabel } from '../../../helpers/periods';
+import { Period } from '../../../types/types';
export interface ProjectLeakPeriodInfoProps extends WrappedComponentProps {
- leakPeriod: T.Period;
+ leakPeriod: Period;
}
export function ProjectLeakPeriodInfo(props: ProjectLeakPeriodInfoProps) {
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { QualityGateStatus } from '../../../types/quality-gates';
+import { Component } from '../../../types/types';
import SonarLintPromotion from '../components/SonarLintPromotion';
import QualityGatePanelSection from './QualityGatePanelSection';
export interface QualityGatePanelProps {
- component: Pick<T.Component, 'key' | 'qualifier'>;
+ component: Pick<Component, 'key' | 'qualifier'>;
loading?: boolean;
qgStatuses?: QualityGateStatus[];
}
import { BranchLike } from '../../../types/branch-like';
import { ComponentQualifier } from '../../../types/component';
import { QualityGateStatus } from '../../../types/quality-gates';
+import { Component } from '../../../types/types';
import QualityGateConditions from '../components/QualityGateConditions';
export interface QualityGatePanelSectionProps {
branchLike?: BranchLike;
- component: Pick<T.Component, 'key' | 'qualifier'>;
+ component: Pick<Component, 'key' | 'qualifier'>;
qgStatus: QualityGateStatus;
}
import { translate } from '../../../helpers/l10n';
import { findMeasure, formatMeasure } from '../../../helpers/measures';
import { MetricKey } from '../../../types/metrics';
+import { MeasureEnhanced } from '../../../types/types';
export interface SecurityHotspotsReviewedProps {
- measures: T.MeasureEnhanced[];
+ measures: MeasureEnhanced[];
useDiffMetric?: boolean;
}
import { ComponentQualifier } from '../../../../types/component';
import { MetricKey } from '../../../../types/metrics';
import { GraphType } from '../../../../types/project-activity';
+import { Measure, Metric } from '../../../../types/types';
import BranchOverview, { BRANCH_OVERVIEW_ACTIVITY_GRAPH, NO_CI_DETECTED } from '../BranchOverview';
import BranchOverviewRenderer from '../BranchOverviewRenderer';
const { mockMeasure, mockMetric } = jest.requireActual('../../../../helpers/testMocks');
return {
getMeasuresWithPeriodAndMetrics: jest.fn((_, metricKeys: string[]) => {
- const metrics: T.Metric[] = [];
- const measures: T.Measure[] = [];
+ const metrics: Metric[] = [];
+ const measures: Measure[] = [];
metricKeys.forEach(key => {
if (key === 'unknown_metric') {
return;
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { AnalysisEvent } from '../../../../types/types';
import { Event } from '../Event';
it('should render an event correctly', () => {
});
it('should render rich quality gate event', () => {
- const event: T.AnalysisEvent = {
+ const event: AnalysisEvent = {
category: 'QUALITY_GATE',
key: 'foo1234',
name: '',
import * as React from 'react';
import { IntlShape } from 'react-intl';
import { mockPeriod } from '../../../../helpers/testMocks';
+import { Period } from '../../../../types/types';
import { ProjectLeakPeriodInfo } from '../ProjectLeakPeriodInfo';
jest.mock('date-fns', () => {
).toMatchSnapshot();
});
-function shallowRender(period: Partial<T.Period> = {}) {
+function shallowRender(period: Partial<Period> = {}) {
return shallow(
<ProjectLeakPeriodInfo
intl={
import { ProjectAlmBindingResponse } from '../../../types/alm-settings';
import { BranchLike } from '../../../types/branch-like';
import { isPortfolioLike } from '../../../types/component';
+import { AppState, Component } from '../../../types/types';
import BranchOverview from '../branches/BranchOverview';
const EmptyOverview = lazyLoadComponent(() => import('./EmptyOverview'));
const PullRequestOverview = lazyLoadComponent(() => import('../pullRequests/PullRequestOverview'));
interface Props {
- appState: Pick<T.AppState, 'branchesEnabled'>;
+ appState: Pick<AppState, 'branchesEnabled'>;
branchLike?: BranchLike;
branchLikes: BranchLike[];
- component: T.Component;
+ component: Component;
isInProgress?: boolean;
isPending?: boolean;
projectBinding?: ProjectAlmBindingResponse;
import { ProjectAlmBindingResponse } from '../../../types/alm-settings';
import { BranchLike } from '../../../types/branch-like';
import { ComponentQualifier } from '../../../types/component';
+import { Component, CurrentUser } from '../../../types/types';
export interface EmptyOverviewProps {
branchLike?: BranchLike;
branchLikes: BranchLike[];
- component: T.Component;
- currentUser: T.CurrentUser;
+ component: Component;
+ currentUser: CurrentUser;
hasAnalyses?: boolean;
projectBinding?: ProjectAlmBindingResponse;
}
import { getComponentIssuesUrl, getComponentSecurityHotspotsUrl } from '../../../helpers/urls';
import { BranchLike } from '../../../types/branch-like';
import { IssueType } from '../../../types/issues';
+import { Component, MeasureEnhanced } from '../../../types/types';
import { getIssueIconClass, getIssueMetricKey } from '../utils';
export interface IssueLabelProps {
branchLike?: BranchLike;
- component: T.Component;
+ component: Component;
helpTooltip?: string;
- measures: T.MeasureEnhanced[];
+ measures: MeasureEnhanced[];
type: IssueType;
useDiffMetric?: boolean;
}
import { findMeasure } from '../../../helpers/measures';
import { BranchLike } from '../../../types/branch-like';
import { IssueType } from '../../../types/issues';
+import { Component, MeasureEnhanced } from '../../../types/types';
import { getIssueRatingMetricKey, getIssueRatingName } from '../utils';
export interface IssueRatingProps {
branchLike?: BranchLike;
- component: T.Component;
- measures: T.MeasureEnhanced[];
+ component: Component;
+ measures: MeasureEnhanced[];
type: IssueType;
useDiffMetric?: boolean;
}
import DateTimeFormatter, { formatterOption } from '../../../components/intl/DateTimeFormatter';
import { translateWithParameters } from '../../../helpers/l10n';
import { getPeriodDate, getPeriodLabel } from '../../../helpers/periods';
+import { Dict, Period } from '../../../types/types';
interface Props {
- period: T.Period;
+ period: Period;
}
-const MODE_INCLUDES_TIME: T.Dict<boolean> = {
+const MODE_INCLUDES_TIME: Dict<boolean> = {
manual_baseline: true,
SPECIFIC_ANALYSIS: true
};
import { translate } from '../../../helpers/l10n';
import { findMeasure, formatMeasure } from '../../../helpers/measures';
import { BranchLike } from '../../../types/branch-like';
+import { Component, MeasureEnhanced } from '../../../types/types';
import {
getMeasurementIconClass,
getMeasurementLabelKeys,
interface Props {
branchLike?: BranchLike;
centered?: boolean;
- component: T.Component;
- measures: T.MeasureEnhanced[];
+ component: Component;
+ measures: MeasureEnhanced[];
type: MeasurementType;
useDiffMetric?: boolean;
}
import { IssueType } from '../../../types/issues';
import { MetricKey } from '../../../types/metrics';
import { QualityGateStatusConditionEnhanced } from '../../../types/quality-gates';
+import { Component, Dict } from '../../../types/types';
interface Props {
branchLike?: BranchLike;
- component: Pick<T.Component, 'key'>;
+ component: Pick<Component, 'key'>;
condition: QualityGateStatusConditionEnhanced;
}
export default class QualityGateCondition extends React.PureComponent<Props> {
- getIssuesUrl = (sinceLeakPeriod: boolean, customQuery: T.Dict<string>) => {
- const query: T.Dict<string | undefined> = {
+ getIssuesUrl = (sinceLeakPeriod: boolean, customQuery: Dict<string>) => {
+ const query: Dict<string | undefined> = {
resolved: 'false',
...getBranchLikeQuery(this.props.branchLike),
...customQuery
};
getUrlForSecurityHotspot(sinceLeakPeriod: boolean) {
- const query: T.Dict<string | undefined> = {
+ const query: Dict<string | undefined> = {
...getBranchLikeQuery(this.props.branchLike)
};
if (sinceLeakPeriod) {
const metricKey = condition.measure.metric.key;
- const METRICS_TO_URL_MAPPING: T.Dict<() => Location> = {
+ const METRICS_TO_URL_MAPPING: Dict<() => Location> = {
[MetricKey.reliability_rating]: () =>
this.getUrlForBugsOrVulnerabilities(IssueType.Bug, false),
[MetricKey.new_reliability_rating]: () =>
import { translateWithParameters } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
import { QualityGateStatusConditionEnhanced } from '../../../types/quality-gates';
+import { Component } from '../../../types/types';
import QualityGateCondition from './QualityGateCondition';
const LEVEL_ORDER = ['ERROR', 'WARN'];
export interface QualityGateConditionsProps {
branchLike?: BranchLike;
- component: Pick<T.Component, 'key'>;
+ component: Pick<Component, 'key'>;
collapsible?: boolean;
failedConditions: QualityGateStatusConditionEnhanced[];
}
import { translate } from '../../../helpers/l10n';
import { MetricKey } from '../../../types/metrics';
import { QualityGateStatusCondition } from '../../../types/quality-gates';
+import { CurrentUser } from '../../../types/types';
export interface SonarLintPromotionProps {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
qgConditions?: QualityGateStatusCondition[];
}
import { shallow } from 'enzyme';
import * as React from 'react';
import { IntlShape } from 'react-intl';
+import { Period } from '../../../../types/types';
import { LeakPeriodLegend } from '../LeakPeriodLegend';
jest.mock('date-fns', () => {
).toMatchSnapshot();
});
-function getWrapper(period: Partial<T.Period> = {}) {
+function getWrapper(period: Partial<Period> = {}) {
return shallow(
<LeakPeriodLegend
intl={
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
import { findMeasure, formatMeasure } from '../../../helpers/measures';
+import { MeasureEnhanced } from '../../../types/types';
import { getMeasurementAfterMergeMetricKey, MeasurementType } from '../utils';
export interface AfterMergeEstimateProps {
className?: string;
- measures: T.MeasureEnhanced[];
+ measures: MeasureEnhanced[];
type: MeasurementType;
}
import HelpIcon from '../../../components/icons/HelpIcon';
import { translate } from '../../../helpers/l10n';
import { getQualityGatesUrl, getQualityGateUrl } from '../../../helpers/urls';
+import { Component, Status } from '../../../types/types';
interface Props {
- component: T.Component;
- level?: T.Status;
+ component: Component;
+ level?: Status;
}
export function LargeQualityGateBadge({ component, level }: Props) {
import { BranchLike, PullRequest } from '../../../types/branch-like';
import { IssueType } from '../../../types/issues';
import { QualityGateStatusCondition } from '../../../types/quality-gates';
+import { Component, MeasureEnhanced, Status } from '../../../types/types';
import IssueLabel from '../components/IssueLabel';
import IssueRating from '../components/IssueRating';
import MeasurementLabel from '../components/MeasurementLabel';
interface StateProps {
conditions?: QualityGateStatusCondition[];
ignoredConditions?: boolean;
- status?: T.Status;
+ status?: Status;
}
interface DispatchProps {
interface OwnProps {
branchLike: PullRequest;
- component: T.Component;
+ component: Component;
}
type Props = StateProps & DispatchProps & OwnProps;
interface State {
loading: boolean;
- measures: T.MeasureEnhanced[];
+ measures: MeasureEnhanced[];
}
export class PullRequestOverview extends React.PureComponent<Props, State> {
import { Router, withRouter } from '../../../components/hoc/withRouter';
import QualifierIcon from '../../../components/icons/QualifierIcon';
import { translate } from '../../../helpers/l10n';
+import { PermissionTemplate } from '../../../types/types';
import { PERMISSION_TEMPLATES_PATH } from '../utils';
import DeleteForm from './DeleteForm';
import Form from './Form';
interface Props {
fromDetails?: boolean;
- permissionTemplate: T.PermissionTemplate;
+ permissionTemplate: PermissionTemplate;
refresh: () => void;
router: Pick<Router, 'replace'>;
topQualifiers: string[];
import Suggestions from '../../../app/components/embed-docs-modal/Suggestions';
import { translate } from '../../../helpers/l10n';
import { getAppState, Store } from '../../../store/rootReducer';
+import { Permission, PermissionTemplate } from '../../../types/types';
import '../../permissions/styles.css';
import { mergeDefaultsToTemplates, mergePermissionsToTemplates, sortPermissions } from '../utils';
import Home from './Home';
interface State {
ready: boolean;
- permissions: T.Permission[];
- permissionTemplates: T.PermissionTemplate[];
+ permissions: Permission[];
+ permissionTemplates: PermissionTemplate[];
}
export class App extends React.PureComponent<Props, State> {
import { sortBy } from 'lodash';
import * as React from 'react';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { PermissionTemplate } from '../../../types/types';
interface Props {
- template: T.PermissionTemplate;
+ template: PermissionTemplate;
}
export default function Defaults({ template }: Props) {
import SimpleModal from '../../../components/controls/SimpleModal';
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { PermissionTemplate } from '../../../types/types';
interface Props {
onClose: () => void;
onSubmit: () => Promise<void>;
- permissionTemplate: T.PermissionTemplate;
+ permissionTemplate: PermissionTemplate;
}
export default function DeleteForm({ onClose, onSubmit, permissionTemplate: t }: Props) {
import * as React from 'react';
import { Helmet } from 'react-helmet-async';
import { translate } from '../../../helpers/l10n';
+import { Permission, PermissionTemplate } from '../../../types/types';
import Header from './Header';
import List from './List';
interface Props {
- permissionTemplates: T.PermissionTemplate[];
- permissions: T.Permission[];
+ permissionTemplates: PermissionTemplate[];
+ permissions: Permission[];
ready: boolean;
refresh: () => Promise<void>;
topQualifiers: string[];
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { Permission, PermissionTemplate } from '../../../types/types';
import ListHeader from './ListHeader';
import ListItem from './ListItem';
interface Props {
- permissionTemplates: T.PermissionTemplate[];
- permissions: T.Permission[];
+ permissionTemplates: PermissionTemplate[];
+ permissions: Permission[];
refresh: () => Promise<void>;
topQualifiers: string[];
}
import HelpTooltip from '../../../components/controls/HelpTooltip';
import { Alert } from '../../../components/ui/Alert';
import { translate } from '../../../helpers/l10n';
+import { Permission } from '../../../types/types';
interface Props {
- permissions: T.Permission[];
+ permissions: Permission[];
}
export default class ListHeader extends React.PureComponent<Props> {
- renderTooltip(permission: T.Permission) {
+ renderTooltip(permission: Permission) {
return permission.key === 'user' || permission.key === 'codeviewer' ? (
<div>
<InstanceMessage message={translate('projects_role', permission.key, 'desc')} />
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { PermissionTemplate } from '../../../types/types';
import ActionsCell from './ActionsCell';
import NameCell from './NameCell';
import PermissionCell from './PermissionCell';
interface Props {
refresh: () => Promise<void>;
- template: T.PermissionTemplate;
+ template: PermissionTemplate;
topQualifiers: string[];
}
*/
import * as React from 'react';
import { Link } from 'react-router';
+import { PermissionTemplate } from '../../../types/types';
import { PERMISSION_TEMPLATES_PATH } from '../utils';
import Defaults from './Defaults';
interface Props {
- template: T.PermissionTemplate;
+ template: PermissionTemplate;
}
export default function NameCell({ template }: Props) {
import { Helmet } from 'react-helmet-async';
import * as api from '../../../api/permissions';
import { translate } from '../../../helpers/l10n';
+import { PermissionGroup, PermissionTemplate, PermissionUser } from '../../../types/types';
import HoldersList from '../../permissions/shared/components/HoldersList';
import SearchForm from '../../permissions/shared/components/SearchForm';
import {
interface Props {
refresh: () => void;
- template: T.PermissionTemplate;
+ template: PermissionTemplate;
topQualifiers: string[];
}
interface State {
filter: string;
- groups: T.PermissionGroup[];
+ groups: PermissionGroup[];
loading: boolean;
query: string;
selectedPermission?: string;
- users: T.PermissionUser[];
+ users: PermissionUser[];
}
export default class Template extends React.PureComponent<Props, State> {
});
};
- handleToggleUser = (user: T.PermissionUser, permission: string) => {
+ handleToggleUser = (user: PermissionUser, permission: string) => {
if (user.login === '<creator>') {
return this.handleToggleProjectCreator(user, permission);
}
return request.then(() => this.requestHolders()).then(this.props.refresh);
};
- handleToggleProjectCreator = (user: T.PermissionUser, permission: string) => {
+ handleToggleProjectCreator = (user: PermissionUser, permission: string) => {
const { template } = this.props;
const hasPermission = user.permissions.includes(permission);
const request = hasPermission
return request.then(() => this.requestHolders()).then(this.props.refresh);
};
- handleToggleGroup = (group: T.PermissionGroup, permission: string) => {
+ handleToggleGroup = (group: PermissionGroup, permission: string) => {
const { template } = this.props;
const hasPermission = group.permissions.includes(permission);
const data = {
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { PermissionTemplate } from '../../../types/types';
import Defaults from './Defaults';
interface Props {
- template: T.PermissionTemplate;
+ template: PermissionTemplate;
}
export default function TemplateDetails({ template }: Props) {
import * as React from 'react';
import { Link } from 'react-router';
import { translate } from '../../../helpers/l10n';
+import { PermissionTemplate } from '../../../types/types';
import { PERMISSION_TEMPLATES_PATH } from '../utils';
import ActionsCell from './ActionsCell';
interface Props {
loading: boolean;
refresh: () => void;
- template: T.PermissionTemplate;
+ template: PermissionTemplate;
topQualifiers: string[];
}
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { PermissionTemplate } from '../../../../types/types';
import Defaults from '../Defaults';
-const SAMPLE: T.PermissionTemplate = {
+const SAMPLE: PermissionTemplate = {
createdAt: '2018-01-01',
defaultFor: [],
id: 'id',
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { sortBy } from 'lodash';
+import { Permission, PermissionTemplate } from '../../types/types';
export const PERMISSIONS_ORDER = [
'user',
export const PERMISSION_TEMPLATES_PATH = '/permission_templates';
-export function sortPermissions(permissions: T.Permission[]) {
+export function sortPermissions(permissions: Permission[]) {
return sortBy(permissions, p => PERMISSIONS_ORDER.indexOf(p.key));
}
export function mergePermissionsToTemplates(
- permissionTemplates: T.PermissionTemplate[],
- basePermissions: T.Permission[]
-): T.PermissionTemplate[] {
+ permissionTemplates: PermissionTemplate[],
+ basePermissions: Permission[]
+): PermissionTemplate[] {
return permissionTemplates.map(permissionTemplate => {
// it's important to keep the order of the permission template's permissions
// the same as the order of base permissions
}
export function mergeDefaultsToTemplates(
- permissionTemplates: T.PermissionTemplate[],
+ permissionTemplates: PermissionTemplate[],
defaultTemplates: Array<{ templateId: string; qualifier: string }> = []
-): T.PermissionTemplate[] {
+): PermissionTemplate[] {
return permissionTemplates.map(permissionTemplate => {
const defaultFor: string[] = [];
import ListFooter from '../../../../components/controls/ListFooter';
import { getAppState, Store } from '../../../../store/rootReducer';
import { ComponentQualifier } from '../../../../types/component';
+import { AppState, Paging, PermissionGroup, PermissionUser } from '../../../../types/types';
import HoldersList from '../../shared/components/HoldersList';
import SearchForm from '../../shared/components/SearchForm';
import {
} from '../../utils';
interface StateProps {
- appState: Pick<T.AppState, 'qualifiers'>;
+ appState: Pick<AppState, 'qualifiers'>;
}
interface OwnProps {
filter: string;
grantPermissionToGroup: (groupName: string, permission: string) => Promise<void>;
grantPermissionToUser: (login: string, permission: string) => Promise<void>;
- groups: T.PermissionGroup[];
- groupsPaging?: T.Paging;
+ groups: PermissionGroup[];
+ groupsPaging?: Paging;
loadHolders: () => void;
loading?: boolean;
onLoadMore: () => void;
query: string;
revokePermissionFromGroup: (groupName: string, permission: string) => Promise<void>;
revokePermissionFromUser: (login: string, permission: string) => Promise<void>;
- users: T.PermissionUser[];
- usersPaging?: T.Paging;
+ users: PermissionUser[];
+ usersPaging?: Paging;
}
type Props = StateProps & OwnProps;
export class AllHoldersList extends React.PureComponent<Props> {
- handleToggleUser = (user: T.PermissionUser, permission: string) => {
+ handleToggleUser = (user: PermissionUser, permission: string) => {
const hasPermission = user.permissions.includes(permission);
if (hasPermission) {
return this.props.revokePermissionFromUser(user.login, permission);
}
};
- handleToggleGroup = (group: T.PermissionGroup, permission: string) => {
+ handleToggleGroup = (group: PermissionGroup, permission: string) => {
const hasPermission = group.permissions.includes(permission);
if (hasPermission) {
import * as api from '../../../../api/permissions';
import Suggestions from '../../../../app/components/embed-docs-modal/Suggestions';
import { translate } from '../../../../helpers/l10n';
+import { Paging, PermissionGroup, PermissionUser } from '../../../../types/types';
import '../../styles.css';
import AllHoldersList from './AllHoldersList';
import PageHeader from './PageHeader';
interface State {
filter: 'all' | 'groups' | 'users';
- groups: T.PermissionGroup[];
- groupsPaging?: T.Paging;
+ groups: PermissionGroup[];
+ groupsPaging?: Paging;
loading: boolean;
query: string;
- users: T.PermissionUser[];
- usersPaging?: T.Paging;
+ users: PermissionUser[];
+ usersPaging?: Paging;
}
export default class App extends React.PureComponent<{}, State> {
loadUsersAndGroups = (userPage?: number, groupsPage?: number) => {
const { filter, query } = this.state;
- const getUsers: Promise<{ paging?: T.Paging; users: T.PermissionUser[] }> =
+ const getUsers: Promise<{ paging?: Paging; users: PermissionUser[] }> =
filter !== 'groups'
? api.getGlobalPermissionsUsers({
q: query || undefined,
})
: Promise.resolve({ paging: undefined, users: [] });
- const getGroups: Promise<{ paging?: T.Paging; groups: T.PermissionGroup[] }> =
+ const getGroups: Promise<{ paging?: Paging; groups: PermissionGroup[] }> =
filter !== 'users'
? api.getGlobalPermissionsGroups({
q: query || undefined,
this.setState({ query }, this.loadHolders);
};
- addPermissionToGroup = (groups: T.PermissionGroup[], group: string, permission: string) => {
+ addPermissionToGroup = (groups: PermissionGroup[], group: string, permission: string) => {
return groups.map(candidate =>
candidate.name === group
? { ...candidate, permissions: [...candidate.permissions, permission] }
);
};
- addPermissionToUser = (users: T.PermissionUser[], user: string, permission: string) => {
+ addPermissionToUser = (users: PermissionUser[], user: string, permission: string) => {
return users.map(candidate =>
candidate.login === user
? { ...candidate, permissions: [...candidate.permissions, permission] }
);
};
- removePermissionFromGroup = (groups: T.PermissionGroup[], group: string, permission: string) => {
+ removePermissionFromGroup = (groups: PermissionGroup[], group: string, permission: string) => {
return groups.map(candidate =>
candidate.name === group
? { ...candidate, permissions: without(candidate.permissions, permission) }
);
};
- removePermissionFromUser = (users: T.PermissionUser[], user: string, permission: string) => {
+ removePermissionFromUser = (users: PermissionUser[], user: string, permission: string) => {
return users.map(candidate =>
candidate.login === user
? { ...candidate, permissions: without(candidate.permissions, permission) }
import { without } from 'lodash';
import * as React from 'react';
import ListFooter from '../../../../components/controls/ListFooter';
+import {
+ Component,
+ Paging,
+ PermissionGroup,
+ PermissionUser,
+ Visibility
+} from '../../../../types/types';
import HoldersList from '../../shared/components/HoldersList';
import SearchForm from '../../shared/components/SearchForm';
import { convertToPermissionDefinitions, PERMISSIONS_ORDER_BY_QUALIFIER } from '../../utils';
interface Props {
- component: T.Component;
+ component: Component;
filter: string;
grantPermissionToGroup: (group: string, permission: string) => Promise<void>;
grantPermissionToUser: (user: string, permission: string) => Promise<void>;
- groups: T.PermissionGroup[];
- groupsPaging?: T.Paging;
+ groups: PermissionGroup[];
+ groupsPaging?: Paging;
onLoadMore: () => void;
onFilterChange: (filter: string) => void;
onPermissionSelect: (permissions?: string) => void;
revokePermissionFromGroup: (group: string, permission: string) => Promise<void>;
revokePermissionFromUser: (user: string, permission: string) => Promise<void>;
selectedPermission?: string;
- users: T.PermissionUser[];
- usersPaging?: T.Paging;
- visibility?: T.Visibility;
+ users: PermissionUser[];
+ usersPaging?: Paging;
+ visibility?: Visibility;
}
export default class AllHoldersList extends React.PureComponent<Props> {
- handleToggleUser = (user: T.PermissionUser, permission: string) => {
+ handleToggleUser = (user: PermissionUser, permission: string) => {
const hasPermission = user.permissions.includes(permission);
if (hasPermission) {
}
};
- handleToggleGroup = (group: T.PermissionGroup, permission: string) => {
+ handleToggleGroup = (group: PermissionGroup, permission: string) => {
const hasPermission = group.permissions.includes(permission);
if (hasPermission) {
import * as api from '../../../../api/permissions';
import VisibilitySelector from '../../../../components/common/VisibilitySelector';
import { translate } from '../../../../helpers/l10n';
+import { Component, Paging, PermissionGroup, PermissionUser } from '../../../../types/types';
import '../../styles.css';
import AllHoldersList from './AllHoldersList';
import PageHeader from './PageHeader';
import PublicProjectDisclaimer from './PublicProjectDisclaimer';
interface Props {
- component: T.Component;
- onComponentChange: (changes: Partial<T.Component>) => void;
+ component: Component;
+ onComponentChange: (changes: Partial<Component>) => void;
}
interface State {
disclaimer: boolean;
filter: string;
- groups: T.PermissionGroup[];
- groupsPaging?: T.Paging;
+ groups: PermissionGroup[];
+ groupsPaging?: Paging;
loading: boolean;
query: string;
selectedPermission?: string;
- users: T.PermissionUser[];
- usersPaging?: T.Paging;
+ users: PermissionUser[];
+ usersPaging?: Paging;
}
export default class App extends React.PureComponent<Props, State> {
const { component } = this.props;
const { filter, query, selectedPermission } = this.state;
- const getUsers: Promise<{ paging?: T.Paging; users: T.PermissionUser[] }> =
+ const getUsers: Promise<{ paging?: Paging; users: PermissionUser[] }> =
filter !== 'groups'
? api.getPermissionsUsersForComponent({
projectKey: component.key,
})
: Promise.resolve({ paging: undefined, users: [] });
- const getGroups: Promise<{ paging?: T.Paging; groups: T.PermissionGroup[] }> =
+ const getGroups: Promise<{ paging?: Paging; groups: PermissionGroup[] }> =
filter !== 'users'
? api.getPermissionsGroupsForComponent({
projectKey: component.key,
import MandatoryFieldMarker from '../../../../components/ui/MandatoryFieldMarker';
import MandatoryFieldsExplanation from '../../../../components/ui/MandatoryFieldsExplanation';
import { translate, translateWithParameters } from '../../../../helpers/l10n';
+import { PermissionTemplate } from '../../../../types/types';
interface Props {
onApply?: () => void;
done: boolean;
loading: boolean;
permissionTemplate?: string;
- permissionTemplates?: T.PermissionTemplate[];
+ permissionTemplates?: PermissionTemplate[];
}
export default class ApplyTemplate extends React.PureComponent<Props, State> {
import { Button } from '../../../../components/controls/buttons';
import { translate } from '../../../../helpers/l10n';
import { isApplication, isPortfolioLike } from '../../../../types/component';
+import { Component } from '../../../../types/types';
import ApplyTemplate from './ApplyTemplate';
interface Props {
- component: T.Component;
+ component: Component;
loadHolders: () => void;
loading: boolean;
}
import { without } from 'lodash';
import * as React from 'react';
import GroupIcon from '../../../../components/icons/GroupIcon';
+import { PermissionDefinitions, PermissionGroup } from '../../../../types/types';
import { isPermissionDefinitionGroup } from '../../utils';
import PermissionCell from './PermissionCell';
interface Props {
- group: T.PermissionGroup;
- onToggle: (group: T.PermissionGroup, permission: string) => Promise<void>;
- permissions: T.PermissionDefinitions;
+ group: PermissionGroup;
+ onToggle: (group: PermissionGroup, permission: string) => Promise<void>;
+ permissions: PermissionDefinitions;
selectedPermission?: string;
}
import { partition, sortBy } from 'lodash';
import * as React from 'react';
import { translate } from '../../../../helpers/l10n';
+import {
+ Dict,
+ PermissionDefinitions,
+ PermissionGroup,
+ PermissionUser
+} from '../../../../types/types';
import { isPermissionDefinitionGroup } from '../../utils';
import GroupHolder from './GroupHolder';
import PermissionHeader from './PermissionHeader';
interface Props {
filter?: string;
- groups: T.PermissionGroup[];
+ groups: PermissionGroup[];
loading?: boolean;
onSelectPermission?: (permission: string) => void;
- onToggleGroup: (group: T.PermissionGroup, permission: string) => Promise<void>;
- onToggleUser: (user: T.PermissionUser, permission: string) => Promise<void>;
- permissions: T.PermissionDefinitions;
+ onToggleGroup: (group: PermissionGroup, permission: string) => Promise<void>;
+ onToggleUser: (user: PermissionUser, permission: string) => Promise<void>;
+ permissions: PermissionDefinitions;
query?: string;
selectedPermission?: string;
showPublicProjectsWarning?: boolean;
- users: T.PermissionUser[];
+ users: PermissionUser[];
}
interface State {
- initialPermissionsCount: T.Dict<number>;
+ initialPermissionsCount: Dict<number>;
}
export default class HoldersList extends React.PureComponent<Props, State> {
state: State = { initialPermissionsCount: {} };
}
}
- isPermissionUser(item: T.PermissionGroup | T.PermissionUser): item is T.PermissionUser {
- return (item as T.PermissionUser).login !== undefined;
+ isPermissionUser(item: PermissionGroup | PermissionUser): item is PermissionUser {
+ return (item as PermissionUser).login !== undefined;
}
- handleGroupToggle = (group: T.PermissionGroup, permission: string) => {
+ handleGroupToggle = (group: PermissionGroup, permission: string) => {
const key = group.id || group.name;
if (this.state.initialPermissionsCount[key] === undefined) {
this.setState(state => ({
return this.props.onToggleGroup(group, permission);
};
- handleUserToggle = (user: T.PermissionUser, permission: string) => {
+ handleUserToggle = (user: PermissionUser, permission: string) => {
if (this.state.initialPermissionsCount[user.login] === undefined) {
this.setState(state => ({
initialPermissionsCount: {
return this.props.onToggleUser(user, permission);
};
- getItemInitialPermissionsCount = (item: T.PermissionGroup | T.PermissionUser) => {
+ getItemInitialPermissionsCount = (item: PermissionGroup | PermissionUser) => {
const key = this.isPermissionUser(item) ? item.login : item.id || item.name;
return this.state.initialPermissionsCount[key] !== undefined
? this.state.initialPermissionsCount[key]
);
}
- renderItem(item: T.PermissionUser | T.PermissionGroup, permissions: T.PermissionDefinitions) {
+ renderItem(item: PermissionUser | PermissionGroup, permissions: PermissionDefinitions) {
return this.isPermissionUser(item) ? (
<UserHolder
key={`user-${item.login}`}
import classNames from 'classnames';
import * as React from 'react';
import Checkbox from '../../../../components/controls/Checkbox';
+import {
+ PermissionDefinition,
+ PermissionDefinitionGroup,
+ PermissionGroup,
+ PermissionUser
+} from '../../../../types/types';
import { isPermissionDefinitionGroup } from '../../utils';
interface Props {
loading: string[];
onCheck: (checked: boolean, permission?: string) => void;
- permission: T.PermissionDefinition | T.PermissionDefinitionGroup;
- permissionItem: T.PermissionGroup | T.PermissionUser;
+ permission: PermissionDefinition | PermissionDefinitionGroup;
+ permissionItem: PermissionGroup | PermissionUser;
selectedPermission?: string;
}
import Tooltip from '../../../../components/controls/Tooltip';
import { Alert } from '../../../../components/ui/Alert';
import { translate, translateWithParameters } from '../../../../helpers/l10n';
+import { PermissionDefinition, PermissionDefinitionGroup } from '../../../../types/types';
import { isPermissionDefinitionGroup } from '../../utils';
interface Props {
onSelectPermission?: (permission: string) => void;
- permission: T.PermissionDefinition | T.PermissionDefinitionGroup;
+ permission: PermissionDefinition | PermissionDefinitionGroup;
selectedPermission?: string;
showPublicProjectsWarning?: boolean;
}
import * as React from 'react';
import Avatar from '../../../../components/ui/Avatar';
import { translate } from '../../../../helpers/l10n';
+import { PermissionDefinitions, PermissionUser } from '../../../../types/types';
import { isPermissionDefinitionGroup } from '../../utils';
import PermissionCell from './PermissionCell';
interface Props {
- onToggle: (user: T.PermissionUser, permission: string) => Promise<void>;
- permissions: T.PermissionDefinitions;
+ onToggle: (user: PermissionUser, permission: string) => Promise<void>;
+ permissions: PermissionDefinitions;
selectedPermission?: string;
- user: T.PermissionUser;
+ user: PermissionUser;
}
interface State {
*/
import { hasMessage, translate } from '../../helpers/l10n';
import { isSonarCloud } from '../../helpers/system';
+import { Dict, PermissionDefinition, PermissionDefinitionGroup } from '../../types/types';
export const PERMISSIONS_ORDER_FOR_PROJECT_TEMPLATE = [
'user',
export const PERMISSIONS_ORDER_FOR_DEV = ['user', 'admin'];
-export const PERMISSIONS_ORDER_BY_QUALIFIER: T.Dict<string[]> = {
+export const PERMISSIONS_ORDER_BY_QUALIFIER: Dict<string[]> = {
TRK: PERMISSIONS_ORDER_FOR_PROJECT_TEMPLATE,
VW: PERMISSIONS_ORDER_FOR_VIEW,
SVW: PERMISSIONS_ORDER_FOR_VIEW,
export function convertToPermissionDefinitions(
permissions: Array<string | { category: string; permissions: string[] }>,
l10nPrefix: string
-): Array<T.PermissionDefinition | T.PermissionDefinitionGroup> {
+): Array<PermissionDefinition | PermissionDefinitionGroup> {
return permissions.map(permission => {
if (typeof permission === 'object') {
return {
}
export function isPermissionDefinitionGroup(
- permission?: T.PermissionDefinition | T.PermissionDefinitionGroup
-): permission is T.PermissionDefinitionGroup {
- return Boolean(permission && (permission as T.PermissionDefinitionGroup).category);
+ permission?: PermissionDefinition | PermissionDefinitionGroup
+): permission is PermissionDefinitionGroup {
+ return Boolean(permission && (permission as PermissionDefinitionGroup).category);
}
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+import { AnalysisEvent } from '../../types/types';
import { State } from './components/ProjectActivityAppContainer';
-export function addCustomEvent(analysis: string, event: T.AnalysisEvent) {
+export function addCustomEvent(analysis: string, event: AnalysisEvent) {
return (state: State) => ({
analyses: state.analyses.map(item => {
if (item.key !== analysis) {
});
}
-export function changeEvent(analysis: string, event: T.AnalysisEvent) {
+export function changeEvent(analysis: string, event: AnalysisEvent) {
return (state: State) => ({
analyses: state.analyses.map(item => {
if (item.key !== analysis) {
import { limitComponentName } from '../../../helpers/path';
import { getProjectUrl } from '../../../helpers/urls';
import { BranchLike } from '../../../types/branch-like';
+import { AnalysisEvent } from '../../../types/types';
-export type DefinitionChangeEvent = T.AnalysisEvent &
- Required<Pick<T.AnalysisEvent, 'definitionChange'>>;
+export type DefinitionChangeEvent = AnalysisEvent &
+ Required<Pick<AnalysisEvent, 'definitionChange'>>;
-export function isDefinitionChangeEvent(event: T.AnalysisEvent): event is DefinitionChangeEvent {
+export function isDefinitionChangeEvent(event: AnalysisEvent): event is DefinitionChangeEvent {
return event.category === 'DEFINITION_CHANGE' && event.definitionChange !== undefined;
}
import * as React from 'react';
import { DeleteButton, EditButton } from '../../../components/controls/buttons';
import { translate } from '../../../helpers/l10n';
+import { AnalysisEvent } from '../../../types/types';
import EventInner from './EventInner';
import ChangeEventForm from './forms/ChangeEventForm';
import RemoveEventForm from './forms/RemoveEventForm';
export interface EventProps {
analysisKey: string;
canAdmin?: boolean;
- event: T.AnalysisEvent;
+ event: AnalysisEvent;
isFirst?: boolean;
onChange?: (event: string, name: string) => Promise<void>;
onDelete?: (analysisKey: string, event: string) => Promise<void>;
import { ComponentContext } from '../../../app/components/ComponentContext';
import Tooltip from '../../../components/controls/Tooltip';
import { translate } from '../../../helpers/l10n';
+import { AnalysisEvent } from '../../../types/types';
import { DefinitionChangeEventInner, isDefinitionChangeEvent } from './DefinitionChangeEventInner';
import { isRichQualityGateEvent, RichQualityGateEventInner } from './RichQualityGateEventInner';
export interface EventInnerProps {
- event: T.AnalysisEvent;
+ event: AnalysisEvent;
readonly?: boolean;
}
*/
import { sortBy } from 'lodash';
import * as React from 'react';
+import { AnalysisEvent } from '../../../types/types';
import Event from './Event';
export interface EventsProps {
analysisKey: string;
canAdmin?: boolean;
- events: T.AnalysisEvent[];
+ events: AnalysisEvent[];
isFirst?: boolean;
onChange?: (event: string, name: string) => Promise<void>;
onDelete?: (analysis: string, event: string) => Promise<void>;
import { toShortNotSoISOString } from '../../../helpers/dates';
import { translate } from '../../../helpers/l10n';
import { ComponentQualifier } from '../../../types/component';
+import { ParsedAnalysis } from '../../../types/types';
import { activityQueryChanged, getAnalysesByVersionByDay, Query } from '../utils';
import ProjectActivityAnalysis from './ProjectActivityAnalysis';
interface Props {
addCustomEvent: (analysis: string, name: string, category?: string) => Promise<void>;
addVersion: (analysis: string, version: string) => Promise<void>;
- analyses: T.ParsedAnalysis[];
+ analyses: ParsedAnalysis[];
analysesLoading: boolean;
canAdmin?: boolean;
canDeleteAnalyses?: boolean;
this.props.updateQuery({ selectedDate: date });
};
- shouldRenderBaselineMarker(analysis: T.ParsedAnalysis): boolean {
+ shouldRenderBaselineMarker(analysis: ParsedAnalysis): boolean {
return Boolean(this.props.leakPeriodDate && isEqual(this.props.leakPeriodDate, analysis.date));
}
- renderAnalysis(analysis: T.ParsedAnalysis) {
+ renderAnalysis(analysis: ParsedAnalysis) {
const firstAnalysisKey = this.props.analyses[0].key;
const selectedDate = this.props.query.selectedDate
import { parseDate } from '../../../helpers/dates';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { scrollToElement } from '../../../helpers/scrolling';
+import { ParsedAnalysis } from '../../../types/types';
import Events from './Events';
import AddEventForm from './forms/AddEventForm';
import RemoveAnalysisForm from './forms/RemoveAnalysisForm';
export interface ProjectActivityAnalysisProps {
addCustomEvent: (analysis: string, name: string, category?: string) => Promise<void>;
addVersion: (analysis: string, version: string) => Promise<void>;
- analysis: T.ParsedAnalysis;
+ analysis: ParsedAnalysis;
canAdmin?: boolean;
canDeleteAnalyses?: boolean;
canCreateVersion: boolean;
import { parseDate } from '../../../helpers/dates';
import { translate } from '../../../helpers/l10n';
import { MeasureHistory } from '../../../types/project-activity';
+import { Component, Metric, ParsedAnalysis } from '../../../types/types';
import { Query } from '../utils';
import './projectActivity.css';
import ProjectActivityAnalysesList from './ProjectActivityAnalysesList';
interface Props {
addCustomEvent: (analysis: string, name: string, category?: string) => Promise<void>;
addVersion: (analysis: string, version: string) => Promise<void>;
- analyses: T.ParsedAnalysis[];
+ analyses: ParsedAnalysis[];
analysesLoading: boolean;
changeEvent: (event: string, name: string) => Promise<void>;
deleteAnalysis: (analysis: string) => Promise<void>;
deleteEvent: (analysis: string, event: string) => Promise<void>;
graphLoading: boolean;
initializing: boolean;
- project: Pick<T.Component, 'configuration' | 'key' | 'leakPeriodDate' | 'qualifier'>;
- metrics: T.Metric[];
+ project: Pick<Component, 'configuration' | 'key' | 'leakPeriodDate' | 'qualifier'>;
+ metrics: Metric[];
measuresHistory: MeasureHistory[];
query: Query;
updateQuery: (changes: Partial<Query>) => void;
import { BranchLike } from '../../../types/branch-like';
import { MetricKey } from '../../../types/metrics';
import { GraphType, MeasureHistory } from '../../../types/project-activity';
+import { Component, Metric, Paging, ParsedAnalysis, RawQuery } from '../../../types/types';
import * as actions from '../actions';
import {
customMetricsChanged,
interface Props {
branchLike?: BranchLike;
- component: T.Component;
+ component: Component;
location: Location;
router: Pick<InjectedRouter, 'push' | 'replace'>;
}
export interface State {
- analyses: T.ParsedAnalysis[];
+ analyses: ParsedAnalysis[];
analysesLoading: boolean;
graphLoading: boolean;
initialized: boolean;
- metrics: T.Metric[];
+ metrics: Metric[];
measuresHistory: MeasureHistory[];
query: Query;
}
});
};
- fetchActivity = (project: string, p: number, ps: number, additional?: T.RawQuery) => {
+ fetchActivity = (project: string, p: number, ps: number, additional?: RawQuery) => {
const parameters = { project, p, ps, ...getBranchLikeQuery(this.props.branchLike) };
return api
.getProjectActivity({ ...additional, ...parameters })
analyses: analyses.map(analysis => ({
...analysis,
date: parseDate(analysis.date)
- })) as T.ParsedAnalysis[],
+ })) as ParsedAnalysis[],
paging
}));
};
loadAllActivities = (
project: string,
- prevResult?: { analyses: T.ParsedAnalysis[]; paging: T.Paging }
- ): Promise<{ analyses: T.ParsedAnalysis[]; paging: T.Paging }> => {
+ prevResult?: { analyses: ParsedAnalysis[]; paging: Paging }
+ ): Promise<{ analyses: ParsedAnalysis[]; paging: Paging }> => {
if (
prevResult &&
prevResult.paging.pageIndex * prevResult.paging.pageSize >= prevResult.paging.total
});
};
- getTopLevelComponent = (component: T.Component) => {
+ getTopLevelComponent = (component: Component) => {
let current = component.breadcrumbs.length - 1;
while (
current > 0 &&
return component.breadcrumbs[current].key;
};
- filterMetrics({ qualifier }: T.Component, metrics: T.Metric[]) {
+ filterMetrics({ qualifier }: Component, metrics: Metric[]) {
return ['VW', 'SVW'].includes(qualifier)
? metrics.filter(metric => metric.key !== MetricKey.security_hotspots_reviewed)
: metrics.filter(metric => metric.key !== MetricKey.security_review_rating);
}
- firstLoadData(query: Query, component: T.Component) {
+ firstLoadData(query: Query, component: Component) {
const graphMetrics = getHistoryMetrics(query.graph || DEFAULT_GRAPH, query.customMetrics);
const topLevelComponent = this.getTopLevelComponent(component);
Promise.all([
splitSeriesInGraphs
} from '../../../components/activity-graph/utils';
import { GraphType, MeasureHistory, Point, Serie } from '../../../types/project-activity';
+import { Metric, ParsedAnalysis } from '../../../types/types';
import { datesQueryChanged, historyQueryChanged, Query } from '../utils';
import { PROJECT_ACTIVITY_GRAPH } from './ProjectActivityAppContainer';
interface Props {
- analyses: T.ParsedAnalysis[];
+ analyses: ParsedAnalysis[];
leakPeriodDate?: Date;
loading: boolean;
measuresHistory: MeasureHistory[];
- metrics: T.Metric[];
+ metrics: Metric[];
project: string;
query: Query;
updateQuery: (changes: Partial<Query>) => void;
*/
import * as React from 'react';
import ListFooter from '../../../components/controls/ListFooter';
+import { Paging } from '../../../types/types';
interface Props {
analyses: unknown[];
fetchMoreActivity: () => void;
- paging?: T.Paging;
+ paging?: Paging;
}
export default function ProjectActivityPageFooter({ analyses, fetchMoreActivity, paging }: Props) {
import * as React from 'react';
import SelectLegacy from '../../../components/controls/SelectLegacy';
import { translate } from '../../../helpers/l10n';
+import { Component } from '../../../types/types';
import { APPLICATION_EVENT_TYPES, EVENT_TYPES, Query } from '../utils';
import ProjectActivityDateInput from './ProjectActivityDateInput';
import ProjectActivityEventSelectOption from './ProjectActivityEventSelectOption';
interface Props {
category?: string;
from?: Date;
- project: Pick<T.Component, 'qualifier'>;
+ project: Pick<Component, 'qualifier'>;
to?: Date;
updateQuery: (changes: Partial<Query>) => void;
}
import Level from '../../../components/ui/Level';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { getProjectUrl } from '../../../helpers/urls';
+import { AnalysisEvent } from '../../../types/types';
-export type RichQualityGateEvent = T.AnalysisEvent & Required<Pick<T.AnalysisEvent, 'qualityGate'>>;
+export type RichQualityGateEvent = AnalysisEvent & Required<Pick<AnalysisEvent, 'qualityGate'>>;
-export function isRichQualityGateEvent(event: T.AnalysisEvent): event is RichQualityGateEvent {
+export function isRichQualityGateEvent(event: AnalysisEvent): event is RichQualityGateEvent {
return event.category === 'QUALITY_GATE' && event.qualityGate !== undefined;
}
import * as React from 'react';
import ConfirmModal from '../../../../components/controls/ConfirmModal';
import { translate } from '../../../../helpers/l10n';
+import { ParsedAnalysis } from '../../../../types/types';
interface Props {
addEvent: (analysis: string, name: string, category?: string) => Promise<void>;
addEventButtonText: string;
- analysis: T.ParsedAnalysis;
+ analysis: ParsedAnalysis;
onClose: () => void;
}
import * as React from 'react';
import ConfirmModal from '../../../../components/controls/ConfirmModal';
import { translate } from '../../../../helpers/l10n';
+import { AnalysisEvent } from '../../../../types/types';
interface Props {
changeEvent: (event: string, name: string) => Promise<void>;
- event: T.AnalysisEvent;
+ event: AnalysisEvent;
header: string;
onClose: () => void;
}
import * as React from 'react';
import ConfirmModal from '../../../../components/controls/ConfirmModal';
import { translate } from '../../../../helpers/l10n';
+import { ParsedAnalysis } from '../../../../types/types';
interface Props {
- analysis: T.ParsedAnalysis;
+ analysis: ParsedAnalysis;
deleteAnalysis: (analysis: string) => Promise<void>;
onClose: () => void;
}
import * as React from 'react';
import ConfirmModal from '../../../../components/controls/ConfirmModal';
import { translate } from '../../../../helpers/l10n';
+import { AnalysisEvent } from '../../../../types/types';
export interface RemoveEventFormProps {
analysisKey: string;
- event: T.AnalysisEvent;
+ event: AnalysisEvent;
header: string;
removeEventQuestion: string;
onClose: () => void;
serializeStringArray
} from '../../helpers/query';
import { GraphType } from '../../types/project-activity';
+import { Dict, ParsedAnalysis, RawQuery } from '../../types/types';
export interface Query {
category: string;
}
interface AnalysesByDay {
- byDay: T.Dict<T.ParsedAnalysis[]>;
+ byDay: Dict<ParsedAnalysis[]>;
version: string | null;
key: string | null;
}
export function getAnalysesByVersionByDay(
- analyses: T.ParsedAnalysis[],
+ analyses: ParsedAnalysis[],
query: Pick<Query, 'category' | 'from' | 'to'>
) {
return analyses.reduce<AnalysesByDay[]>((acc, analysis) => {
}, []);
}
-export function parseQuery(urlQuery: T.RawQuery): Query {
+export function parseQuery(urlQuery: RawQuery): Query {
return {
category: parseAsString(urlQuery['category']),
customMetrics: parseAsArray(urlQuery['custom_metrics'], parseAsString),
};
}
-export function serializeQuery(query: Query): T.RawQuery {
+export function serializeQuery(query: Query): RawQuery {
return cleanQuery({
category: serializeString(query.category),
from: serializeDate(query.from),
});
}
-export function serializeUrlQuery(query: Query): T.RawQuery {
+export function serializeUrlQuery(query: Query): RawQuery {
return cleanQuery({
category: serializeString(query.category),
custom_metrics: serializeStringArray(query.customMetrics),
import { isBranch, sortBranches } from '../../../helpers/branch-like';
import { translate } from '../../../helpers/l10n';
import { Branch, BranchLike } from '../../../types/branch-like';
+import {
+ Component,
+ NewCodePeriod,
+ NewCodePeriodSettingType,
+ ParsedAnalysis
+} from '../../../types/types';
import '../styles.css';
import { getSettingValue } from '../utils';
import AppHeader from './AppHeader';
branchLikes: BranchLike[];
branchesEnabled?: boolean;
canAdmin?: boolean;
- component: T.Component;
+ component: Component;
}
interface State {
analysis?: string;
branchList: Branch[];
- currentSetting?: T.NewCodePeriodSettingType;
+ currentSetting?: NewCodePeriodSettingType;
currentSettingValue?: string;
days: string;
- generalSetting?: T.NewCodePeriod;
+ generalSetting?: NewCodePeriod;
loading: boolean;
overrideGeneralSetting?: boolean;
referenceBranch?: string;
saving: boolean;
- selected?: T.NewCodePeriodSettingType;
+ selected?: NewCodePeriodSettingType;
success?: boolean;
}
const DEFAULT_NUMBER_OF_DAYS = '30';
-const DEFAULT_GENERAL_SETTING: { type: T.NewCodePeriodSettingType } = {
+const DEFAULT_GENERAL_SETTING: { type: NewCodePeriodSettingType } = {
type: 'PREVIOUS_VERSION'
};
}
getUpdatedState(params: {
- currentSetting?: T.NewCodePeriodSettingType;
+ currentSetting?: NewCodePeriodSettingType;
currentSettingValue?: string;
- generalSetting: T.NewCodePeriod;
+ generalSetting: NewCodePeriod;
}) {
const { currentSetting, currentSettingValue, generalSetting } = params;
const { referenceBranch } = this.state;
);
};
- handleSelectAnalysis = (analysis: T.ParsedAnalysis) => this.setState({ analysis: analysis.key });
+ handleSelectAnalysis = (analysis: ParsedAnalysis) => this.setState({ analysis: analysis.key });
handleSelectDays = (days: string) => this.setState({ days });
this.getUpdatedState({ generalSetting, currentSetting, currentSettingValue })
);
- handleSelectSetting = (selected?: T.NewCodePeriodSettingType) => this.setState({ selected });
+ handleSelectSetting = (selected?: NewCodePeriodSettingType) => this.setState({ selected });
handleToggleSpecificSetting = (overrideGeneralSetting: boolean) =>
this.setState({ overrideGeneralSetting });
import * as React from 'react';
import RadioCard from '../../../components/controls/RadioCard';
import { translate } from '../../../helpers/l10n';
+import { NewCodePeriodSettingType } from '../../../types/types';
export interface Props {
disabled?: boolean;
- onSelect: (selection: T.NewCodePeriodSettingType) => void;
+ onSelect: (selection: NewCodePeriodSettingType) => void;
selected: boolean;
}
import ValidationInput from '../../../components/controls/ValidationInput';
import MandatoryFieldsExplanation from '../../../components/ui/MandatoryFieldsExplanation';
import { translate } from '../../../helpers/l10n';
+import { NewCodePeriodSettingType } from '../../../types/types';
export interface Props {
className?: string;
isChanged: boolean;
isValid: boolean;
onChangeDays: (value: string) => void;
- onSelect: (selection: T.NewCodePeriodSettingType) => void;
+ onSelect: (selection: NewCodePeriodSettingType) => void;
selected: boolean;
}
import * as React from 'react';
import RadioCard from '../../../components/controls/RadioCard';
import { translate } from '../../../helpers/l10n';
+import { NewCodePeriodSettingType } from '../../../types/types';
export interface Props {
disabled?: boolean;
isDefault?: boolean;
- onSelect: (selection: T.NewCodePeriodSettingType) => void;
+ onSelect: (selection: NewCodePeriodSettingType) => void;
selected: boolean;
}
import MandatoryFieldMarker from '../../../components/ui/MandatoryFieldMarker';
import MandatoryFieldsExplanation from '../../../components/ui/MandatoryFieldsExplanation';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { NewCodePeriodSettingType } from '../../../types/types';
export interface BaselineSettingReferenceBranchProps {
branchList: BranchOption[];
configuredBranchName?: string;
disabled?: boolean;
onChangeReferenceBranch: (value: string) => void;
- onSelect: (selection: T.NewCodePeriodSettingType) => void;
+ onSelect: (selection: NewCodePeriodSettingType) => void;
referenceBranch: string;
selected: boolean;
settingLevel: 'project' | 'branch';
import { getProjectActivity } from '../../../api/projectActivity';
import { parseDate, toShortNotSoISOString } from '../../../helpers/dates';
import { scrollToElement } from '../../../helpers/scrolling';
+import { Analysis, Dict, ParsedAnalysis } from '../../../types/types';
import BranchAnalysisListRenderer from './BranchAnalysisListRenderer';
interface Props {
analysis: string;
branch: string;
component: string;
- onSelectAnalysis: (analysis: T.ParsedAnalysis) => void;
+ onSelectAnalysis: (analysis: ParsedAnalysis) => void;
}
interface State {
- analyses: T.ParsedAnalysis[];
+ analyses: ParsedAnalysis[];
loading: boolean;
range: number;
scroll: number;
export default class BranchAnalysisList extends React.PureComponent<Props, State> {
mounted = false;
- badges: T.Dict<HTMLDivElement> = {};
+ badges: Dict<HTMLDivElement> = {};
scrollableNode?: HTMLDivElement;
state: State = {
analyses: [],
branch,
project: component,
from: range ? toShortNotSoISOString(subDays(new Date(), range)) : undefined
- }).then((result: { analyses: T.Analysis[] }) => {
+ }).then((result: { analyses: Analysis[] }) => {
// If the selected analysis wasn't found in the default 30 days range, redo the search
if (initial && analysis && !result.analyses.find(a => a.key === analysis)) {
this.handleRangeChange({ value: 0 });
analyses: result.analyses.map(analysis => ({
...analysis,
date: parseDate(analysis.date)
- })) as T.ParsedAnalysis[],
+ })) as ParsedAnalysis[],
loading: false
},
() => {
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { parseDate, toShortNotSoISOString } from '../../../helpers/dates';
import { translate } from '../../../helpers/l10n';
+import { ParsedAnalysis } from '../../../types/types';
import Events from '../../projectActivity/components/Events';
import { getAnalysesByVersionByDay } from '../../projectActivity/utils';
export interface BranchAnalysisListRendererProps {
- analyses: T.ParsedAnalysis[];
+ analyses: ParsedAnalysis[];
handleRangeChange: ({ value }: { value: number }) => void;
handleScroll: (e: React.SyntheticEvent<HTMLDivElement>) => void;
loading: boolean;
- onSelectAnalysis: (analysis: T.ParsedAnalysis) => void;
+ onSelectAnalysis: (analysis: ParsedAnalysis) => void;
range: number;
registerBadgeNode: (version: string) => (el: HTMLDivElement) => void;
registerScrollableNode: (el: HTMLDivElement) => void;
}
function renderAnalysis(args: {
- analysis: T.ParsedAnalysis;
+ analysis: ParsedAnalysis;
isFirst: boolean;
- onSelectAnalysis: (analysis: T.ParsedAnalysis) => void;
+ onSelectAnalysis: (analysis: ParsedAnalysis) => void;
selectedAnalysisKey: string;
}) {
const { analysis, isFirst, onSelectAnalysis, selectedAnalysisKey } = args;
import { toNotSoISOString } from '../../../helpers/dates';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { Branch, BranchWithNewCodePeriod } from '../../../types/branch-like';
+import { NewCodePeriod, NewCodePeriodSettingType, ParsedAnalysis } from '../../../types/types';
import { getSettingValue, validateSetting } from '../utils';
import BaselineSettingAnalysis from './BaselineSettingAnalysis';
import BaselineSettingDays from './BaselineSettingDays';
branch: BranchWithNewCodePeriod;
branchList: Branch[];
component: string;
- onClose: (branch?: string, newSetting?: T.NewCodePeriod) => void;
+ onClose: (branch?: string, newSetting?: NewCodePeriod) => void;
}
interface State {
days: string;
referenceBranch: string;
saving: boolean;
- selected?: T.NewCodePeriodSettingType;
+ selected?: NewCodePeriodSettingType;
}
export default class BranchBaselineSettingModal extends React.PureComponent<Props, State> {
this.mounted = false;
}
- getValueFromProps(type: T.NewCodePeriodSettingType) {
+ getValueFromProps(type: NewCodePeriodSettingType) {
return this.props.branch.newCodePeriod && this.props.branch.newCodePeriod.type === type
? this.props.branch.newCodePeriod.value
: null;
requestClose = () => this.props.onClose();
- handleSelectAnalysis = (analysis: T.ParsedAnalysis) =>
+ handleSelectAnalysis = (analysis: ParsedAnalysis) =>
this.setState({ analysis: analysis.key, analysisDate: analysis.date });
handleSelectDays = (days: string) => this.setState({ days });
handleSelectReferenceBranch = (referenceBranch: string) => this.setState({ referenceBranch });
- handleSelectSetting = (selected: T.NewCodePeriodSettingType) => this.setState({ selected });
+ handleSelectSetting = (selected: NewCodePeriodSettingType) => this.setState({ selected });
render() {
const { branch, branchList } = this.props;
import { isBranch, sortBranches } from '../../../helpers/branch-like';
import { translate } from '../../../helpers/l10n';
import { Branch, BranchLike, BranchWithNewCodePeriod } from '../../../types/branch-like';
+import { Component, NewCodePeriod } from '../../../types/types';
import BranchBaselineSettingModal from './BranchBaselineSettingModal';
import BranchListRow from './BranchListRow';
interface Props {
branchList: Branch[];
- component: T.Component;
- inheritedSetting: T.NewCodePeriod;
+ component: Component;
+ inheritedSetting: NewCodePeriod;
}
interface State {
);
}
- updateBranchNewCodePeriod = (branch: string, newSetting: T.NewCodePeriod | undefined) => {
+ updateBranchNewCodePeriod = (branch: string, newSetting: NewCodePeriod | undefined) => {
const { branches } = this.state;
const updated = branches.find(b => b.name === branch);
this.setState({ editedBranch: branch });
};
- closeEditModal = (branch?: string, newSetting?: T.NewCodePeriod) => {
+ closeEditModal = (branch?: string, newSetting?: NewCodePeriod) => {
if (branch) {
this.setState({
branches: this.updateBranchNewCodePeriod(branch, newSetting),
import DateTimeFormatter from '../../../components/intl/DateTimeFormatter';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { BranchWithNewCodePeriod } from '../../../types/branch-like';
+import { NewCodePeriod } from '../../../types/types';
export interface BranchListRowProps {
branch: BranchWithNewCodePeriod;
existingBranches: Array<string>;
- inheritedSetting: T.NewCodePeriod;
+ inheritedSetting: NewCodePeriod;
onOpenEditModal: (branch: BranchWithNewCodePeriod) => void;
onResetToDefault: (branchName: string) => void;
}
-function renderNewCodePeriodSetting(newCodePeriod: T.NewCodePeriod) {
+function renderNewCodePeriodSetting(newCodePeriod: NewCodePeriod) {
switch (newCodePeriod.type) {
case 'SPECIFIC_ANALYSIS':
return (
function branchInheritsItselfAsReference(
branch: BranchWithNewCodePeriod,
- inheritedSetting: T.NewCodePeriod
+ inheritedSetting: NewCodePeriod
) {
return (
!branch.newCodePeriod &&
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { Branch } from '../../../types/branch-like';
+import { NewCodePeriod, NewCodePeriodSettingType, ParsedAnalysis } from '../../../types/types';
import { validateSetting } from '../utils';
import BaselineSettingAnalysis from './BaselineSettingAnalysis';
import BaselineSettingDays from './BaselineSettingDays';
branchList: Branch[];
branchesEnabled?: boolean;
component: string;
- currentSetting?: T.NewCodePeriodSettingType;
+ currentSetting?: NewCodePeriodSettingType;
currentSettingValue?: string;
days: string;
- generalSetting: T.NewCodePeriod;
+ generalSetting: NewCodePeriod;
onCancel: () => void;
- onSelectAnalysis: (analysis: T.ParsedAnalysis) => void;
+ onSelectAnalysis: (analysis: ParsedAnalysis) => void;
onSelectDays: (value: string) => void;
onSelectReferenceBranch: (value: string) => void;
- onSelectSetting: (value?: T.NewCodePeriodSettingType) => void;
+ onSelectSetting: (value?: NewCodePeriodSettingType) => void;
onSubmit: (e: React.SyntheticEvent<HTMLFormElement>) => void;
onToggleSpecificSetting: (selection: boolean) => void;
referenceBranch?: string;
saving: boolean;
- selected?: T.NewCodePeriodSettingType;
+ selected?: NewCodePeriodSettingType;
overrideGeneralSetting: boolean;
}
-function renderGeneralSetting(generalSetting: T.NewCodePeriod) {
+function renderGeneralSetting(generalSetting: NewCodePeriod) {
let setting: string;
let description: string;
if (generalSetting.type === 'NUMBER_OF_DAYS') {
+import { NewCodePeriodSettingType } from '../../types/types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
analysis?: string;
days?: string;
referenceBranch?: string;
- type?: T.NewCodePeriodSettingType;
+ type?: NewCodePeriodSettingType;
}) {
switch (type) {
case 'NUMBER_OF_DAYS':
export function validateSetting(state: {
analysis?: string;
- currentSetting?: T.NewCodePeriodSettingType;
+ currentSetting?: NewCodePeriodSettingType;
currentSettingValue?: string;
days: string;
overrideGeneralSetting?: boolean;
referenceBranch?: string;
- selected?: T.NewCodePeriodSettingType;
+ selected?: NewCodePeriodSettingType;
}) {
const {
analysis = '',
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
+import { Component } from '../../../types/types';
import BranchLikeTabs from './BranchLikeTabs';
import LifetimeInformation from './LifetimeInformation';
export interface AppProps {
branchLikes: BranchLike[];
- component: T.Component;
+ component: Component;
onBranchesChange: () => void;
}
} from '../../../helpers/branch-like';
import { translate } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
+import { Component } from '../../../types/types';
import BranchPurgeSetting from './BranchPurgeSetting';
export interface BranchLikeRowProps {
branchLike: BranchLike;
- component: T.Component;
+ component: Component;
displayPurgeSetting?: boolean;
onDelete: () => void;
onRename: () => void;
import { getBranchLikeKey } from '../../../helpers/branch-like';
import { translate } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
+import { Component } from '../../../types/types';
import BranchLikeRow from './BranchLikeRow';
export interface BranchLikeTableProps {
branchLikes: BranchLike[];
- component: T.Component;
+ component: Component;
displayPurgeSetting?: boolean;
onDelete: (branchLike: BranchLike) => void;
onRename: (branchLike: BranchLike) => void;
} from '../../../helpers/branch-like';
import { translate } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
+import { Component } from '../../../types/types';
import BranchLikeTable from './BranchLikeTable';
import DeleteBranchModal from './DeleteBranchModal';
import RenameBranchModal from './RenameBranchModal';
interface Props {
branchLikes: BranchLike[];
- component: T.Component;
+ component: Component;
onBranchesChange: () => void;
}
import { isMainBranch } from '../../../helpers/branch-like';
import { translate } from '../../../helpers/l10n';
import { Branch } from '../../../types/branch-like';
+import { Component } from '../../../types/types';
interface Props {
branch: Branch;
- component: T.Component;
+ component: Component;
}
interface State {
import { getBranchLikeDisplayName, isPullRequest } from '../../../helpers/branch-like';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
+import { Component } from '../../../types/types';
interface Props {
branchLike: BranchLike;
- component: T.Component;
+ component: Component;
onClose: () => void;
onDelete: () => void;
}
import MandatoryFieldsExplanation from '../../../components/ui/MandatoryFieldsExplanation';
import { translate } from '../../../helpers/l10n';
import { MainBranch } from '../../../types/branch-like';
+import { Component } from '../../../types/types';
interface Props {
branch: MainBranch;
- component: T.Component;
+ component: Component;
onClose: () => void;
onRename: () => void;
}
import * as React from 'react';
import { Helmet } from 'react-helmet-async';
import { translate } from '../../helpers/l10n';
+import { Component } from '../../types/types';
import Form from './Form';
import Header from './Header';
interface Props {
- component: Pick<T.Component, 'key' | 'name' | 'qualifier'>;
+ component: Pick<Component, 'key' | 'name' | 'qualifier'>;
}
export default function App(props: Props) {
import { Router, withRouter } from '../../components/hoc/withRouter';
import { translate, translateWithParameters } from '../../helpers/l10n';
import { isApplication, isPortfolioLike } from '../../types/component';
+import { Component } from '../../types/types';
interface Props {
- component: Pick<T.Component, 'key' | 'name' | 'qualifier'>;
+ component: Pick<Component, 'key' | 'name' | 'qualifier'>;
router: Pick<Router, 'replace'>;
}
*/
import * as React from 'react';
import { translate } from '../../helpers/l10n';
+import { Component } from '../../types/types';
interface Props {
- component: Pick<T.Component, 'qualifier'>;
+ component: Pick<Component, 'qualifier'>;
}
export default function Header(props: Props) {
import { translate } from '../../helpers/l10n';
import { DumpStatus, DumpTask } from '../../types/project-dump';
import { TaskStatuses, TaskTypes } from '../../types/tasks';
+import { AppState, Component } from '../../types/types';
import Export from './components/Export';
import Import from './components/Import';
import './styles.css';
const POLL_INTERNAL = 5000;
interface Props {
- appState: Pick<T.AppState, 'projectImportFeatureEnabled'>;
- component: T.Component;
+ appState: Pick<AppState, 'projectImportFeatureEnabled'>;
+ component: Component;
}
interface State {
import { changeKey } from '../../api/components';
import RecentHistory from '../../app/components/RecentHistory';
import { translate } from '../../helpers/l10n';
+import { Component } from '../../types/types';
import UpdateForm from './UpdateForm';
interface Props {
- component: Pick<T.Component, 'key' | 'name'>;
+ component: Pick<Component, 'key' | 'name'>;
}
export class Key extends React.PureComponent<Props & WithRouterProps> {
import { translate, translateWithParameters } from '../../helpers/l10n';
import { validateProjectKey } from '../../helpers/projects';
import { ProjectKeyValidationResult } from '../../types/component';
+import { Component } from '../../types/types';
export interface UpdateFormProps {
- component: Pick<T.Component, 'key' | 'name'>;
+ component: Pick<Component, 'key' | 'name'>;
onKeyChange: (newKey: string) => Promise<void>;
}
import { createLink, deleteLink, getProjectLinks } from '../../api/projectLinks';
import DeferredSpinner from '../../components/ui/DeferredSpinner';
import { translate } from '../../helpers/l10n';
+import { Component, ProjectLink } from '../../types/types';
import Header from './Header';
import Table from './Table';
interface Props {
- component: Pick<T.Component, 'key'>;
+ component: Pick<Component, 'key'>;
}
interface State {
- links?: T.ProjectLink[];
+ links?: ProjectLink[];
loading: boolean;
}
import ProjectLinkIcon from '../../components/icons/ProjectLinkIcon';
import { translate, translateWithParameters } from '../../helpers/l10n';
import { getLinkName, isProvided } from '../../helpers/projectLinks';
+import { ProjectLink } from '../../types/types';
interface Props {
- link: T.ProjectLink;
+ link: ProjectLink;
onDelete: (linkId: string) => Promise<void>;
}
export default class LinkRow extends React.PureComponent<Props> {
- renderNameForProvided = (link: T.ProjectLink) => {
+ renderNameForProvided = (link: ProjectLink) => {
return (
<div className="display-inline-block text-top">
<div>
);
};
- renderName = (link: T.ProjectLink) => {
+ renderName = (link: ProjectLink) => {
return (
<div>
<ProjectLinkIcon className="little-spacer-right" type={link.type} />
);
};
- renderDeleteButton = (link: T.ProjectLink) => {
+ renderDeleteButton = (link: ProjectLink) => {
if (isProvided(link)) {
return null;
}
import * as React from 'react';
import { translate } from '../../helpers/l10n';
import { orderLinks } from '../../helpers/projectLinks';
+import { ProjectLink } from '../../types/types';
import LinkRow from './LinkRow';
interface Props {
- links: T.ProjectLink[];
+ links: ProjectLink[];
onDelete: (linkId: string) => Promise<void>;
}
import addGlobalSuccessMessage from '../../app/utils/addGlobalSuccessMessage';
import handleRequiredAuthorization from '../../app/utils/handleRequiredAuthorization';
import { translate } from '../../helpers/l10n';
+import { Component, QualityGate } from '../../types/types';
import { USE_SYSTEM_DEFAULT } from './constants';
import ProjectQualityGateAppRenderer from './ProjectQualityGateAppRenderer';
interface Props {
- component: T.Component;
+ component: Component;
onComponentChange: (changes: {}) => void;
}
interface State {
- allQualityGates?: T.QualityGate[];
- currentQualityGate?: T.QualityGate;
+ allQualityGates?: QualityGate[];
+ currentQualityGate?: QualityGate;
loading: boolean;
selectedQualityGateId: string;
submitting: boolean;
return !!hasPermission;
};
- isUsingDefault = async (qualityGate: T.QualityGate) => {
+ isUsingDefault = async (qualityGate: QualityGate) => {
const { component } = this.props;
if (!qualityGate.isDefault) {
import { Alert } from '../../components/ui/Alert';
import { translate } from '../../helpers/l10n';
import { isDiffMetric } from '../../helpers/measures';
+import { QualityGate } from '../../types/types';
import BuiltInQualityGateBadge from '../quality-gates/components/BuiltInQualityGateBadge';
import { USE_SYSTEM_DEFAULT } from './constants';
export interface ProjectQualityGateAppRendererProps {
- allQualityGates?: T.QualityGate[];
- currentQualityGate?: T.QualityGate;
+ allQualityGates?: QualityGate[];
+ currentQualityGate?: QualityGate;
loading: boolean;
onSelect: (id: string) => void;
onSubmit: () => void;
submitting: boolean;
}
-function hasConditionOnNewCode(qualityGate: T.QualityGate): boolean {
+function hasConditionOnNewCode(qualityGate: QualityGate): boolean {
return !!qualityGate.conditions?.some(condition => isDiffMetric(condition.metric));
}
import handleRequiredAuthorization from '../../app/utils/handleRequiredAuthorization';
import { translateWithParameters } from '../../helpers/l10n';
import { isDefined } from '../../helpers/types';
+import { Component } from '../../types/types';
import ProjectQualityProfilesAppRenderer from './ProjectQualityProfilesAppRenderer';
import { ProjectProfile } from './types';
interface Props {
- component: T.Component;
+ component: Component;
}
interface State {
import PlusCircleIcon from '../../components/icons/PlusCircleIcon';
import { translate } from '../../helpers/l10n';
import { getRulesUrl } from '../../helpers/urls';
+import { Component } from '../../types/types';
import BuiltInQualityProfileBadge from '../quality-profiles/components/BuiltInQualityProfileBadge';
import AddLanguageModal from './components/AddLanguageModal';
import SetQualityProfileModal from './components/SetQualityProfileModal';
export interface ProjectQualityProfilesAppRendererProps {
allProfiles?: Profile[];
- component: T.Component;
+ component: Component;
loading: boolean;
onAddLanguage: (key: string) => Promise<void>;
onCloseModal: () => void;
import { translate } from '../../../helpers/l10n';
import { getQualityProfileUrl } from '../../../helpers/urls';
import { Store } from '../../../store/rootReducer';
+import { Dict, Languages } from '../../../types/types';
export interface AddLanguageModalProps {
- languages: T.Languages;
+ languages: Languages;
onClose: () => void;
onSubmit: (key: string) => Promise<void>;
- profilesByLanguage:
T.Dict<Profile[]>;
+ profilesByLanguage: Dict<Profile[]>;
unavailableLanguages: string[];
}
import { Alert } from '../../../components/ui/Alert';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { getQualityProfileUrl } from '../../../helpers/urls';
+import { Component } from '../../../types/types';
import BuiltInQualityProfileBadge from '../../quality-profiles/components/BuiltInQualityProfileBadge';
import { USE_SYSTEM_DEFAULT } from '../constants';
export interface SetQualityProfileModalProps {
availableProfiles: Profile[];
- component: T.Component;
+ component: Component;
currentProfile: Profile;
onClose: () => void;
onSubmit: (newKey: string | undefined, oldKey: string) => Promise<void>;
import { get, save } from '../../../helpers/storage';
import { isLoggedIn } from '../../../helpers/users';
import { ComponentQualifier } from '../../../types/component';
+import { CurrentUser, RawQuery } from '../../../types/types';
import { hasFilterParams, hasVisualizationParams, parseUrlQuery, Query } from '../query';
import '../styles.css';
import { Facets, Project } from '../types';
import ProjectsList from './ProjectsList';
interface Props {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
isFavorite: boolean;
location: Pick<Location, 'pathname' | 'query'>;
qualifiers: ComponentQualifier[];
}
};
- updateLocationQuery = (newQuery: T.RawQuery) => {
+ updateLocationQuery = (newQuery: RawQuery) => {
const query = omitBy({ ...this.props.location.query, ...newQuery }, x => !x);
this.props.router.push({ pathname: this.props.location.pathname, query });
};
import { hasGlobalPermission } from '../../../helpers/users';
import { ComponentQualifier } from '../../../types/component';
import { Permissions } from '../../../types/permissions';
+import { AppState, LoggedInUser } from '../../../types/types';
export interface ApplicationCreationProps {
- appState: Pick<T.AppState, 'qualifiers'>;
+ appState: Pick<AppState, 'qualifiers'>;
className?: string;
- currentUser: T.LoggedInUser;
+ currentUser: LoggedInUser;
router: Router;
}
import { Location, Router, withRouter } from '../../../components/hoc/withRouter';
import { get } from '../../../helpers/storage';
import { hasGlobalPermission, isLoggedIn } from '../../../helpers/users';
+import { CurrentUser } from '../../../types/types';
import { PROJECTS_ALL, PROJECTS_DEFAULT_FILTER, PROJECTS_FAVORITE } from '../utils';
import AllProjectsContainer from './AllProjectsContainer';
interface Props {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
location: Pick<Location, 'pathname' | 'query'>;
router: Pick<Router, 'replace'>;
}
import { translate } from '../../../helpers/l10n';
import { hasGlobalPermission, isLoggedIn } from '../../../helpers/users';
import { Permissions } from '../../../types/permissions';
+import { CurrentUser } from '../../../types/types';
export interface EmptyInstanceProps {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
router: WithRouterProps['router'];
}
import { translate } from '../../../helpers/l10n';
import { save } from '../../../helpers/storage';
import { isLoggedIn } from '../../../helpers/users';
+import { CurrentUser, RawQuery } from '../../../types/types';
import { PROJECTS_ALL, PROJECTS_DEFAULT_FILTER, PROJECTS_FAVORITE } from '../utils';
interface Props {
- currentUser: T.CurrentUser;
- query?: T.RawQuery;
+ currentUser: CurrentUser;
+ query?: RawQuery;
}
export default class FavoriteFilter extends React.PureComponent<Props> {
import Tooltip from '../../../components/controls/Tooltip';
import { translate } from '../../../helpers/l10n';
import { isLoggedIn } from '../../../helpers/users';
+import { CurrentUser, RawQuery } from '../../../types/types';
import SearchFilterContainer from '../filters/SearchFilterContainer';
import { Project } from '../types';
import ApplicationCreation from './ApplicationCreation';
import ProjectsSortingSelect from './ProjectsSortingSelect';
interface Props {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
loading: boolean;
onPerspectiveChange: (x: { view: string; visualization?: string }) => void;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
onSortChange: (sort: string, desc: boolean) => void;
projects?: Project[];
- query: T.RawQuery;
+ query: RawQuery;
selectedSort: string;
total?: number;
view: string;
import { flatMap } from 'lodash';
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { RawQuery } from '../../../types/types';
import CoverageFilter from '../filters/CoverageFilter';
import DuplicationsFilter from '../filters/DuplicationsFilter';
import LanguagesFilterContainer from '../filters/LanguagesFilterContainer';
applicationsEnabled: boolean;
facets?: Facets;
onClearAll: () => void;
- onQueryChange: (change: T.RawQuery) => void;
- query: T.RawQuery;
+ onQueryChange: (change: RawQuery) => void;
+ query: RawQuery;
view: string;
visualization: string;
}
const maxFacetValue = getMaxFacetValue(facets);
const facetProps = { onQueryChange, maxFacetValue };
- let linkQuery: T.RawQuery | undefined = undefined;
+ let linkQuery: RawQuery | undefined = undefined;
if (view !== 'overall') {
linkQuery = { view };
import { hasGlobalPermission } from '../../../helpers/users';
import { AlmKeys, AlmSettingsInstance } from '../../../types/alm-settings';
import { Permissions } from '../../../types/permissions';
+import { LoggedInUser } from '../../../types/types';
import ProjectCreationMenuItem from './ProjectCreationMenuItem';
interface Props {
className?: string;
- currentUser: T.LoggedInUser;
+ currentUser: LoggedInUser;
}
interface State {
import { WindowScroller } from 'react-virtualized/dist/commonjs/WindowScroller';
import EmptySearch from '../../../components/common/EmptySearch';
import { translate } from '../../../helpers/l10n';
+import { CurrentUser } from '../../../types/types';
import { Query } from '../query';
import { Project } from '../types';
import EmptyFavoriteSearch from './EmptyFavoriteSearch';
interface Props {
cardType?: string;
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
handleFavorite: (component: string, isFavorite: boolean) => void;
isFavorite: boolean;
isFiltered: boolean;
import * as React from 'react';
import { get, save } from '../../../../helpers/storage';
import { ComponentQualifier } from '../../../../types/component';
+import { Dict } from '../../../../types/types';
import {
AllProjects,
LS_PROJECTS_SORT,
});
it('redirects to the saved search', () => {
- const localeStorageMock: T.Dict<string> = {
+ const localeStorageMock: Dict<string> = {
[LS_PROJECTS_VIEW]: 'leak',
[LS_PROJECTS_SORT]: 'coverage',
[LS_PROJECTS_VISUALIZATION]: 'security'
} from '../../../../helpers/testMocks';
import { waitAndUpdate } from '../../../../helpers/testUtils';
import { hasGlobalPermission } from '../../../../helpers/users';
+import { CurrentUser } from '../../../../types/types';
import { DefaultPageSelector } from '../DefaultPageSelector';
jest.mock(
jest.mock('../../../../helpers/users', () => ({
hasGlobalPermission: jest.fn().mockReturnValue(false),
- isLoggedIn: jest.fn((u: T.CurrentUser) => u.isLoggedIn)
+ isLoggedIn: jest.fn((u: CurrentUser) => u.isLoggedIn)
}));
jest.mock('../../../../api/components', () => ({
import { isLoggedIn } from '../../../../helpers/users';
import { ComponentQualifier } from '../../../../types/component';
import { MetricKey } from '../../../../types/metrics';
+import { CurrentUser } from '../../../../types/types';
import { Project } from '../../types';
import './ProjectCard.css';
import ProjectCardLanguagesContainer from './ProjectCardLanguagesContainer';
import ProjectCardQualityGate from './ProjectCardQualityGate';
interface Props {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
handleFavorite: (component: string, isFavorite: boolean) => void;
height: number;
project: Project;
import { sortBy } from 'lodash';
import * as React from 'react';
import { translate } from '../../../../helpers/l10n';
+import { Languages } from '../../../../types/types';
interface Props {
className?: string;
distribution?: string;
- languages: T.Languages;
+ languages: Languages;
}
export default function ProjectCardLanguages({ className, distribution, languages }: Props) {
);
}
-function getLanguageName(languages: T.Languages, key: string): string {
+function getLanguageName(languages: Languages, key: string): string {
if (key === '<null>') {
return translate('unknown');
}
import { isDefined } from '../../../../helpers/types';
import { ComponentQualifier } from '../../../../types/component';
import { MetricKey } from '../../../../types/metrics';
+import { Dict } from '../../../../types/types';
import { formatDuration } from '../../utils';
import ProjectCardMeasure from './ProjectCardMeasure';
export interface ProjectCardMeasuresProps {
isNewCode: boolean;
- measures: T.Dict<string | undefined>;
+ measures: Dict<string | undefined>;
componentQualifier: ComponentQualifier;
newCodeStartingDate?: string;
}
import TagsList from '../../../../../components/tags/TagsList';
import { mockCurrentUser, mockLoggedInUser } from '../../../../../helpers/testMocks';
import { ComponentQualifier } from '../../../../../types/component';
+import { CurrentUser } from '../../../../../types/types';
import { Project } from '../../../types';
import ProjectCard from '../ProjectCard';
import ProjectCardQualityGate from '../ProjectCardQualityGate';
).toMatchSnapshot('with project count');
});
-function shallowRender(project: Project, user: T.CurrentUser = USER_LOGGED_OUT, type?: string) {
+function shallowRender(project: Project, user: CurrentUser = USER_LOGGED_OUT, type?: string) {
return shallow(
<ProjectCard
currentUser={user}
import CoverageRating from '../../../../../components/ui/CoverageRating';
import { ComponentQualifier } from '../../../../../types/component';
import { MetricKey } from '../../../../../types/metrics';
+import { Dict } from '../../../../../types/types';
import ProjectCardMeasures, { ProjectCardMeasuresProps } from '../ProjectCardMeasures';
jest.mock('date-fns', () => ({
});
function shallowRender(
- measuresOverride: T.Dict<string | undefined> = {},
+ measuresOverride: Dict<string | undefined> = {},
props: Partial<ProjectCardMeasuresProps> = {}
) {
const measures = {
import CoverageRating from '../../../components/ui/CoverageRating';
import { translate } from '../../../helpers/l10n';
import { getCoverageRatingAverageValue, getCoverageRatingLabel } from '../../../helpers/ratings';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import Filter from './Filter';
import FilterHeader from './FilterHeader';
className?: string;
facet?: Facet;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
property?: string;
value?: any;
}
getDuplicationsRatingAverageValue,
getDuplicationsRatingLabel
} from '../../../helpers/ratings';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import Filter from './Filter';
import FilterHeader from './FilterHeader';
className?: string;
facet?: Facet;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
property?: string;
value?: any;
}
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
import { formatMeasure } from '../../../helpers/measures';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
export type Option = string | number;
interface Props {
property: string;
className?: string;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
options: Option[];
renderOption: (option: Option, isSelected: boolean) => React.ReactNode;
import * as React from 'react';
import Rating from '../../../components/ui/Rating';
import { translate } from '../../../helpers/l10n';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import Filter from './Filter';
import FilterHeader from './FilterHeader';
headerDetail?: React.ReactNode;
maxFacetValue?: number;
name: string;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
property: string;
value?: any;
}
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
import { getLanguageByKey } from '../../../store/languages';
+import { Dict, Languages, RawQuery } from '../../../types/types';
import { Facet } from '../types';
import Filter from './Filter';
import FilterHeader from './FilterHeader';
interface Props {
facet?: Facet;
- languages: T.Languages;
+ languages: Languages;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
property?: string;
+ query: Dict<any>;
value?: string[];
}
import * as React from 'react';
import CodeSmellIcon from '../../../components/icons/CodeSmellIcon';
import { translate } from '../../../helpers/l10n';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import IssuesFilter from './IssuesFilter';
facet?: Facet;
headerDetail?: React.ReactNode;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
value?: any;
}
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
import { getSizeRatingLabel } from '../../../helpers/ratings';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import Filter from './Filter';
import FilterHeader from './FilterHeader';
className?: string;
facet?: Facet;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
property?: string;
value?: any;
}
import * as React from 'react';
import CodeSmellIcon from '../../../components/icons/CodeSmellIcon';
import { translate } from '../../../helpers/l10n';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import IssuesFilter from './IssuesFilter';
className?: string;
facet?: Facet;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
value?: any;
}
import * as React from 'react';
import BugIcon from '../../../components/icons/BugIcon';
import { translate } from '../../../helpers/l10n';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import IssuesFilter from './IssuesFilter';
className?: string;
facet?: Facet;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
value?: any;
}
import * as React from 'react';
import VulnerabilityIcon from '../../../components/icons/VulnerabilityIcon';
import { translate } from '../../../helpers/l10n';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import IssuesFilter from './IssuesFilter';
className?: string;
facet?: Facet;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
value?: any;
}
import QualifierIcon from '../../../components/icons/QualifierIcon';
import { translate } from '../../../helpers/l10n';
import { ComponentQualifier } from '../../../types/component';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import Filter from './Filter';
import FilterHeader from './FilterHeader';
export interface QualifierFilterProps {
facet?: Facet;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
value: ComponentQualifier | undefined;
}
import HelpTooltip from '../../../components/controls/HelpTooltip';
import Level from '../../../components/ui/Level';
import { translate } from '../../../helpers/l10n';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import Filter from './Filter';
import FilterHeader from './FilterHeader';
className?: string;
facet?: Facet;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
value?: any;
}
import * as React from 'react';
import BugIcon from '../../../components/icons/BugIcon';
import { translate } from '../../../helpers/l10n';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import IssuesFilter from './IssuesFilter';
facet?: Facet;
headerDetail?: React.ReactNode;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
value?: any;
}
import * as React from 'react';
import SelectLegacy from '../../../components/controls/SelectLegacy';
import { translate } from '../../../helpers/l10n';
+import { Dict, RawQuery } from '../../../types/types';
interface Props {
isFavorite?: boolean;
isLoading?: boolean;
onInputChange?: (query: string) => void;
onOpen?: () => void;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
options: Array<{ label: string; value: string }>;
property: string;
+ query: Dict<any>;
}
export default class SearchableFilterFooter extends React.PureComponent<Props> {
import * as React from 'react';
import VulnerabilityIcon from '../../../components/icons/VulnerabilityIcon';
import { translate } from '../../../helpers/l10n';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import IssuesFilter from './IssuesFilter';
facet?: Facet;
headerDetail?: React.ReactNode;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
value?: any;
}
import SecurityHotspotIcon from '../../../components/icons/SecurityHotspotIcon';
import Rating from '../../../components/ui/Rating';
import { translate } from '../../../helpers/l10n';
+import { Dict, RawQuery } from '../../../types/types';
import { Facet } from '../types';
import Filter from './Filter';
import FilterHeader from './FilterHeader';
className?: string;
facet?: Facet;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
property?: string;
value?: any;
}
-const labels: T.Dict<string> = {
+const labels: Dict<string> = {
1: '≥ 80%',
2: '70% - 80%',
3: '50% - 70%',
import SizeRating from '../../../components/ui/SizeRating';
import { translate } from '../../../helpers/l10n';
import { getSizeRatingAverageValue, getSizeRatingLabel } from '../../../helpers/ratings';
+import { RawQuery } from '../../../types/types';
import { Facet } from '../types';
import Filter from './Filter';
import FilterHeader from './FilterHeader';
className?: string;
facet?: Facet;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
property?: string;
value?: any;
}
import * as React from 'react';
import { searchProjectTags } from '../../../api/components';
import { translate } from '../../../helpers/l10n';
+import { Dict, RawQuery } from '../../../types/types';
import { Facet } from '../types';
import Filter from './Filter';
import FilterHeader from './FilterHeader';
interface Props {
facet?: Facet;
maxFacetValue?: number;
- onQueryChange: (change: T.RawQuery) => void;
+ onQueryChange: (change: RawQuery) => void;
property?: string;
+ query: Dict<any>;
value?: string[];
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { ComponentQualifier } from '../../types/component';
+import { Dict, RawQuery } from '../../types/types';
import { VISUALIZATIONS } from './utils';
type Level = 'ERROR' | 'WARN' | 'OK';
[x: string]: string | number | string[] | undefined;
}
-export function parseUrlQuery(urlQuery: T.RawQuery): Query {
+export function parseUrlQuery(urlQuery: RawQuery): Query {
return {
gate: getAsLevel(urlQuery['gate']),
reliability: getAsNumericRating(urlQuery['reliability']),
}
function mapPropertyToMetric(property?: string): string | undefined {
- const map: T.Dict<string> = {
+ const map: Dict<string> = {
analysis_date: 'analysisDate',
reliability: 'reliability_rating',
new_reliability: 'new_reliability_rating',
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { ComponentQualifier } from '../../types/component';
+import { Dict, Visibility } from '../../types/types';
export interface Project {
analysisDate?: string;
isFavorite?: boolean;
key: string;
leakPeriodDate?: string;
- measures: T.Dict<string>;
+ measures: Dict<string>;
name: string;
projects?: number;
qualifier: ComponentQualifier;
tags: string[];
- visibility: T.Visibility;
+ visibility: Visibility;
needIssueSync?: boolean;
}
import { isDiffMetric } from '../../helpers/measures';
import { RequestData } from '../../helpers/request';
import { MetricKey } from '../../types/metrics';
+import { Dict } from '../../types/types';
import { convertToFilter, Query } from './query';
interface SortingOption {
{ value: 'new_lines', class: 'projects-leak-sorting-option' }
];
-export const SORTING_SWITCH: T.Dict<string> = {
+export const SORTING_SWITCH: Dict<string> = {
analysis_date: 'analysis_date',
name: 'name',
reliability: 'new_reliability',
MetricKey.projects
];
-const METRICS_BY_VISUALIZATION: T.Dict<string[]> = {
+const METRICS_BY_VISUALIZATION: Dict<string[]> = {
risk: [
MetricKey.reliability_rating,
MetricKey.security_rating,
return {
facets: getFacetsMap(facets),
projects: components.map(component => {
- const componentMeasures: T.Dict<string> = {};
+ const componentMeasures: Dict<string> = {};
measures
.filter(measure => measure.component === component.key)
.forEach(measure => {
}
function mapFacetValues(values: Array<{ val: string; count: number }>) {
- const map: T.Dict<number> = {};
+ const map: Dict<number> = {};
values.forEach(value => {
map[value.val] = value.count;
});
return map;
}
-const propertyToMetricMap: T.Dict<string | undefined> = {
+const propertyToMetricMap: Dict<string | undefined> = {
analysis_date: 'analysisDate',
reliability: 'reliability_rating',
new_reliability: 'new_reliability_rating',
const metricToPropertyMap = invert(propertyToMetricMap);
function getFacetsMap(facets: Facet[]) {
- const map: T.Dict<T.Dict<number>> = {};
+ const map: Dict<Dict<number>> = {};
facets.forEach(facet => {
const property = metricToPropertyMap[facet.property];
const { values } = facet;
*/
import * as React from 'react';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Dict } from '../../../types/types';
import { Project } from '../types';
import { localizeSorting } from '../utils';
import Coverage from './Coverage';
export default class Visualizations extends React.PureComponent<Props> {
renderVisualization(projects: Project[]) {
- const visualizationToComponent:
T.Dict<any> = {
+ const visualizationToComponent: Dict<any> = {
risk: Risk,
reliability: Reliability,
security: Security,
import { getAppState, getCurrentUser, Store } from '../../store/rootReducer';
import { Permissions } from '../../types/permissions';
import { SettingsKey } from '../../types/settings';
+import { AppState, LoggedInUser, Visibility } from '../../types/types';
import CreateProjectForm from './CreateProjectForm';
import Header from './Header';
import Projects from './Projects';
import Search from './Search';
export interface Props {
- currentUser: T.LoggedInUser;
- appState: Pick<T.AppState, 'qualifiers'>;
+ currentUser: LoggedInUser;
+ appState: Pick<AppState, 'qualifiers'>;
}
interface State {
analyzedBefore?: Date;
createProjectForm: boolean;
- defaultProjectVisibility?: T.Visibility;
+ defaultProjectVisibility?: Visibility;
page: number;
projects: Project[];
provisioned: boolean;
ready: boolean;
selection: string[];
total: number;
- visibility?: T.Visibility;
+ visibility?: Visibility;
}
const PAGE_SIZE = 50;
const results = await getValues({ keys: SettingsKey.DefaultProjectVisibility });
if (this.mounted && results.length > 0 && results[0].value) {
- this.setState({ defaultProjectVisibility: results[0].value as T.Visibility });
+ this.setState({ defaultProjectVisibility: results[0].value as Visibility });
}
};
- handleDefaultProjectVisibilityChange = async (visibility: T.Visibility) => {
+ handleDefaultProjectVisibilityChange = async (visibility: Visibility) => {
await changeProjectDefaultVisibility(visibility);
if (this.mounted) {
);
};
- onVisibilityChanged = (newVisibility: T.Visibility | 'all') => {
+ onVisibilityChanged = (newVisibility: Visibility | 'all') => {
this.setState(
{
ready: false,
const mapStateToProps = (state: Store) => ({
appState: getAppState(state),
- currentUser: getCurrentUser(state) as T.LoggedInUser
+ currentUser: getCurrentUser(state) as LoggedInUser
});
export default connect(mapStateToProps)(App);
import MandatoryFieldsExplanation from '../../components/ui/MandatoryFieldsExplanation';
import { toNotSoISOString } from '../../helpers/dates';
import { translate, translateWithParameters } from '../../helpers/l10n';
+import { PermissionTemplate } from '../../types/types';
export interface Props {
analyzedBefore: Date | undefined;
done: boolean;
loading: boolean;
permissionTemplate?: string;
- permissionTemplates?: T.PermissionTemplate[];
+ permissionTemplates?: PermissionTemplate[];
submitting: boolean;
}
import Radio from '../../components/controls/Radio';
import { Alert } from '../../components/ui/Alert';
import { translate } from '../../helpers/l10n';
+import { Visibility } from '../../types/types';
export interface Props {
- defaultVisibility: T.Visibility;
+ defaultVisibility: Visibility;
onClose: () => void;
- onConfirm: (visiblity: T.Visibility) => void;
+ onConfirm: (visiblity: Visibility) => void;
}
interface State {
- visibility: T.Visibility;
+ visibility: Visibility;
}
export default class ChangeDefaultVisibilityForm extends React.PureComponent<Props, State> {
this.props.onClose();
};
- handleVisibilityChange = (visibility: T.Visibility) => {
+ handleVisibilityChange = (visibility: Visibility) => {
this.setState({ visibility });
};
import MandatoryFieldsExplanation from '../../components/ui/MandatoryFieldsExplanation';
import { translate } from '../../helpers/l10n';
import { getProjectUrl } from '../../helpers/urls';
+import { Visibility } from '../../types/types';
interface Props {
- defaultProjectVisibility?: T.Visibility;
+ defaultProjectVisibility?: Visibility;
onClose: () => void;
onProjectCreated: () => void;
}
key: string;
loading: boolean;
name: string;
- visibility?: T.Visibility;
+ visibility?: Visibility;
// add index declaration to be able to do `this.setState({ [name]: value });`
[x: string]: any;
}
this.setState({ [name]: value });
};
- handleVisibilityChange = (visibility: T.Visibility) => {
+ handleVisibilityChange = (visibility: Visibility) => {
this.setState({ visibility });
};
import * as React from 'react';
import { Button, EditButton } from '../../components/controls/buttons';
import { translate } from '../../helpers/l10n';
+import { Visibility } from '../../types/types';
import ChangeDefaultVisibilityForm from './ChangeDefaultVisibilityForm';
export interface Props {
- defaultProjectVisibility?: T.Visibility;
+ defaultProjectVisibility?: Visibility;
hasProvisionPermission?: boolean;
onProjectCreate: () => void;
- onChangeDefaultProjectVisibility: (visibility: T.Visibility) => void;
+ onChangeDefaultProjectVisibility: (visibility: Visibility) => void;
}
interface State {
import QualifierIcon from '../../components/icons/QualifierIcon';
import DateFormatter from '../../components/intl/DateFormatter';
import { getComponentOverviewUrl } from '../../helpers/urls';
+import { LoggedInUser } from '../../types/types';
import './ProjectRow.css';
import ProjectRowActions from './ProjectRowActions';
interface Props {
- currentUser: Pick<T.LoggedInUser, 'login'>;
+ currentUser: Pick<LoggedInUser, 'login'>;
onProjectCheck: (project: Project, checked: boolean) => void;
project: Project;
selected: boolean;
import DeferredSpinner from '../../components/ui/DeferredSpinner';
import { translate } from '../../helpers/l10n';
import { getComponentPermissionsUrl } from '../../helpers/urls';
+import { LoggedInUser } from '../../types/types';
import ApplyTemplate from '../permissions/project/components/ApplyTemplate';
import RestoreAccessModal from './RestoreAccessModal';
export interface Props {
- currentUser: Pick<T.LoggedInUser, 'login'>;
+ currentUser: Pick<LoggedInUser, 'login'>;
project: Project;
}
import * as React from 'react';
import { Project } from '../../api/components';
import { translate } from '../../helpers/l10n';
+import { LoggedInUser } from '../../types/types';
import ProjectRow from './ProjectRow';
interface Props {
- currentUser: Pick<T.LoggedInUser, 'login'>;
+ currentUser: Pick<LoggedInUser, 'login'>;
onProjectDeselected: (project: string) => void;
onProjectSelected: (project: string) => void;
projects: Project[];
import { ResetButtonLink, SubmitButton } from '../../components/controls/buttons';
import Modal from '../../components/controls/Modal';
import { translate } from '../../helpers/l10n';
+import { LoggedInUser } from '../../types/types';
interface Props {
- currentUser: Pick<T.LoggedInUser, 'login'>;
+ currentUser: Pick<LoggedInUser, 'login'>;
onClose: () => void;
onRestoreAccess: () => void;
project: Project;
import SelectLegacy from '../../components/controls/SelectLegacy';
import QualifierIcon from '../../components/icons/QualifierIcon';
import { translate } from '../../helpers/l10n';
+import { Visibility } from '../../types/types';
import BulkApplyTemplateModal from './BulkApplyTemplateModal';
import DeleteModal from './DeleteModal';
selection: any[];
topLevelQualifiers: string[];
total: number;
- visibility?: T.Visibility;
+ visibility?: Visibility;
}
interface State {
removeWhitePageClass
} from '../../../helpers/pages';
import { getQualityGateUrl } from '../../../helpers/urls';
+import { QualityGate } from '../../../types/types';
import '../styles.css';
import Details from './Details';
import List from './List';
interface State {
canCreate: boolean;
loading: boolean;
- qualityGates: T.QualityGate[];
+ qualityGates: QualityGate[];
}
class App extends React.PureComponent<Pick<WithRouterProps, 'params' | 'router'>, State> {
);
};
- openDefault(qualityGates: T.QualityGate[]) {
+ openDefault(qualityGates: QualityGate[]) {
const defaultQualityGate = qualityGates.find(gate => Boolean(gate.isDefault))!;
this.props.router.replace(getQualityGateUrl(String(defaultQualityGate.id)));
}
- handleSetDefault = (qualityGate: T.QualityGate) => {
+ handleSetDefault = (qualityGate: QualityGate) => {
this.setState(({ qualityGates }) => {
return {
qualityGates: qualityGates.map(candidate => {
import ConfirmModal from '../../../components/controls/ConfirmModal';
import { getLocalizedMetricName, translate, translateWithParameters } from '../../../helpers/l10n';
import { formatMeasure } from '../../../helpers/measures';
+import { Condition as ConditionType, Metric, QualityGate } from '../../../types/types';
import { getLocalizedMetricNameNoDiffMetric } from '../utils';
import ConditionModal from './ConditionModal';
interface Props {
- condition: T.Condition;
+ condition: ConditionType;
canEdit: boolean;
- metric: T.Metric;
- onRemoveCondition: (Condition: T.Condition) => void;
- onSaveCondition: (newCondition: T.Condition, oldCondition: T.Condition) => void;
- qualityGate: T.QualityGate;
+ metric: Metric;
+ onRemoveCondition: (Condition: ConditionType) => void;
+ onSaveCondition: (newCondition: ConditionType, oldCondition: ConditionType) => void;
+ qualityGate: QualityGate;
updated?: boolean;
}
};
}
- handleUpdateCondition = (newCondition: T.Condition) => {
+ handleUpdateCondition = (newCondition: ConditionType) => {
this.props.onSaveCondition(newCondition, this.props.condition);
};
this.setState({ deleteFormOpen: false });
};
- removeCondition = (condition: T.Condition) => {
+ removeCondition = (condition: ConditionType) => {
deleteCondition({ id: condition.id }).then(
() => this.props.onRemoveCondition(condition),
() => {}
import { Alert } from '../../../components/ui/Alert';
import { getLocalizedMetricName, translate } from '../../../helpers/l10n';
import { isDiffMetric } from '../../../helpers/measures';
+import { Condition, Metric, QualityGate } from '../../../types/types';
import { getPossibleOperators } from '../utils';
import ConditionOperator from './ConditionOperator';
import MetricSelect from './MetricSelect';
import ThresholdInput from './ThresholdInput';
interface Props {
- condition?: T.Condition;
- metric?: T.Metric;
- metrics?: T.Metric[];
+ condition?: Condition;
+ metric?: Metric;
+ metrics?: Metric[];
header: string;
- onAddCondition: (condition: T.Condition) => void;
+ onAddCondition: (condition: Condition) => void;
onClose: () => void;
- qualityGate: T.QualityGate;
+ qualityGate: QualityGate;
}
interface State {
error: string;
errorMessage?: string;
- metric?: T.Metric;
+ metric?: Metric;
op?: string;
scope: 'new' | 'overall';
}
};
}
- getSinglePossibleOperator(metric: T.Metric) {
+ getSinglePossibleOperator(metric: Metric) {
const operators = getPossibleOperators(metric);
return Array.isArray(operators) ? undefined : operators;
}
handleFormSubmit = () => {
if (this.state.metric) {
const { condition, qualityGate } = this.props;
- const newCondition: T.Omit<T.Condition, 'id'> = {
+ const newCondition: Omit<Condition, 'id'> = {
metric: this.state.metric.key,
op: this.getSinglePossibleOperator(this.state.metric) || this.state.op,
error: this.state.error
});
};
- handleMetricChange = (metric: T.Metric) => {
+ handleMetricChange = (metric: Metric) => {
this.setState({ metric, op: undefined, error: '' });
};
import * as React from 'react';
import SelectLegacy from '../../../components/controls/SelectLegacy';
import { translate } from '../../../helpers/l10n';
+import { Metric } from '../../../types/types';
import { getPossibleOperators } from '../utils';
interface Props {
- metric: T.Metric;
+ metric: Metric;
onOperatorChange: (op: string) => void;
op?: string;
}
this.props.onOperatorChange(value);
};
- getLabel(op: string, metric: T.Metric) {
+ getLabel(op: string, metric: Metric) {
return metric.type === 'RATING'
? translate('quality_gates.operator', op, 'rating')
: translate('quality_gates.operator', op);
import { getLocalizedMetricName, translate } from '../../../helpers/l10n';
import { isDiffMetric } from '../../../helpers/measures';
import { MetricKey } from '../../../types/metrics';
+import {
+ AppState,
+ Condition as ConditionType,
+ Dict,
+ Metric,
+ QualityGate
+} from '../../../types/types';
import Condition from './Condition';
import ConditionModal from './ConditionModal';
interface Props {
- appState: Pick<T.AppState, 'branchesEnabled'>;
+ appState: Pick<AppState, 'branchesEnabled'>;
canEdit: boolean;
- conditions: T.Condition[];
- metrics: T.Dict<T.Metric>;
- onAddCondition: (condition: T.Condition) => void;
- onRemoveCondition: (Condition: T.Condition) => void;
- onSaveCondition: (newCondition: T.Condition, oldCondition: T.Condition) => void;
- qualityGate: T.QualityGate;
+ conditions: ConditionType[];
+ metrics: Dict<Metric>;
+ onAddCondition: (condition: ConditionType) => void;
+ onRemoveCondition: (Condition: ConditionType) => void;
+ onSaveCondition: (newCondition: ConditionType, oldCondition: ConditionType) => void;
+ qualityGate: QualityGate;
updatedConditionId?: number;
}
];
export class Conditions extends React.PureComponent<Props> {
- renderConditionsTable = (conditions: T.Condition[], scope: 'new' | 'overall') => {
+ renderConditionsTable = (conditions: ConditionType[], scope: 'new' | 'overall') => {
const {
qualityGate,
metrics,
isDiffMetric(condition.metric)
);
- const duplicates: T.Condition[] = [];
+ const duplicates: ConditionType[] = [];
const savedConditions = existingConditions.filter(condition => condition.id != null);
savedConditions.forEach(condition => {
const sameCount = savedConditions.filter(sample => sample.metric === condition.metric).length;
import MandatoryFieldsExplanation from '../../../components/ui/MandatoryFieldsExplanation';
import { translate } from '../../../helpers/l10n';
import { getQualityGateUrl } from '../../../helpers/urls';
+import { QualityGate } from '../../../types/types';
interface Props {
onClose: () => void;
onCopy: () => Promise<void>;
- qualityGate: T.QualityGate;
+ qualityGate: QualityGate;
router: Pick<Router, 'push'>;
}
import { Router, withRouter } from '../../../components/hoc/withRouter';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { getQualityGatesUrl } from '../../../helpers/urls';
+import { QualityGate } from '../../../types/types';
interface Props {
onDelete: () => Promise<void>;
- qualityGate: T.QualityGate;
+ qualityGate: QualityGate;
router: Pick<Router, 'push'>;
}
import { translate } from '../../../helpers/l10n';
import { fetchMetrics } from '../../../store/rootActions';
import { getMetrics, Store } from '../../../store/rootReducer';
+import { Condition, Dict, Metric, QualityGate } from '../../../types/types';
import { addCondition, checkIfDefault, deleteCondition, replaceCondition } from '../utils';
import DetailsContent from './DetailsContent';
import DetailsHeader from './DetailsHeader';
interface OwnProps {
id: string;
- onSetDefault: (qualityGate: T.QualityGate) => void;
- qualityGates: T.QualityGate[];
+ onSetDefault: (qualityGate: QualityGate) => void;
+ qualityGates: QualityGate[];
refreshQualityGates: () => Promise<void>;
}
interface StateToProps {
- metrics: T.Dict<T.Metric>;
+ metrics: Dict<Metric>;
}
interface DispatchToProps {
interface State {
loading: boolean;
- qualityGate?: T.QualityGate;
+ qualityGate?: QualityGate;
updatedConditionId?: number;
}
);
};
- handleAddCondition = (condition: T.Condition) => {
+ handleAddCondition = (condition: Condition) => {
this.setState(({ qualityGate }) => {
if (!qualityGate) {
return null;
});
};
- handleSaveCondition = (newCondition: T.Condition, oldCondition: T.Condition) => {
+ handleSaveCondition = (newCondition: Condition, oldCondition: Condition) => {
this.setState(({ qualityGate }) => {
if (!qualityGate) {
return null;
});
};
- handleRemoveCondition = (condition: T.Condition) => {
+ handleRemoveCondition = (condition: Condition) => {
this.setState(({ qualityGate }) => {
if (!qualityGate) {
return null;
return null;
}
this.props.onSetDefault(qualityGate);
- const newQualityGate: T.QualityGate = {
+ const newQualityGate: QualityGate = {
...qualityGate,
actions: { ...qualityGate.actions, delete: false, setAsDefault: false }
};
import HelpTooltip from '../../../components/controls/HelpTooltip';
import { Alert } from '../../../components/ui/Alert';
import { translate } from '../../../helpers/l10n';
+import { Condition, Dict, Metric, QualityGate } from '../../../types/types';
import Conditions from './Conditions';
import Projects from './Projects';
import QualityGatePermissions from './QualityGatePermissions';
export interface DetailsContentProps {
isDefault?: boolean;
- metrics: T.Dict<T.Metric>;
- onAddCondition: (condition: T.Condition) => void;
- onRemoveCondition: (Condition: T.Condition) => void;
- onSaveCondition: (newCondition: T.Condition, oldCondition: T.Condition) => void;
- qualityGate: T.QualityGate;
+ metrics: Dict<Metric>;
+ onAddCondition: (condition: Condition) => void;
+ onRemoveCondition: (Condition: Condition) => void;
+ onSaveCondition: (newCondition: Condition, oldCondition: Condition) => void;
+ qualityGate: QualityGate;
updatedConditionId?: number;
}
import ModalButton from '../../../components/controls/ModalButton';
import Tooltip from '../../../components/controls/Tooltip';
import { translate } from '../../../helpers/l10n';
+import { QualityGate } from '../../../types/types';
import BuiltInQualityGateBadge from './BuiltInQualityGateBadge';
import CopyQualityGateForm from './CopyQualityGateForm';
import DeleteQualityGateForm from './DeleteQualityGateForm';
interface Props {
onSetDefault: () => void;
- qualityGate: T.QualityGate;
+ qualityGate: QualityGate;
refreshItem: () => Promise<void>;
refreshList: () => Promise<void>;
}
import { Link } from 'react-router';
import { translate } from '../../../helpers/l10n';
import { getQualityGateUrl } from '../../../helpers/urls';
+import { QualityGate } from '../../../types/types';
import BuiltInQualityGateBadge from './BuiltInQualityGateBadge';
interface Props {
- qualityGates: T.QualityGate[];
+ qualityGates: QualityGate[];
}
export default function List({ qualityGates }: Props) {
import * as React from 'react';
import SelectLegacy from '../../../components/controls/SelectLegacy';
import { getLocalizedMetricDomain, translate } from '../../../helpers/l10n';
+import { Metric } from '../../../types/types';
import { getLocalizedMetricNameNoDiffMetric } from '../utils';
interface Props {
- metric?: T.Metric;
- metrics: T.Metric[];
- onMetricChange: (metric: T.Metric) => void;
+ metric?: Metric;
+ metrics: Metric[];
+ onMetricChange: (metric: Metric) => void;
}
interface Option {
import GroupIcon from '../../../components/icons/GroupIcon';
import Avatar from '../../../components/ui/Avatar';
import { Group, isUser } from '../../../types/quality-gates';
+import { UserBase } from '../../../types/types';
export interface PermissionItemProps {
- onClickDelete: (item: T.UserBase | Group) => void;
- item: T.UserBase | Group;
+ onClickDelete: (item: UserBase | Group) => void;
+ item: UserBase | Group;
}
export default function PermissionItem(props: PermissionItemProps) {
SelectListSearchParams
} from '../../../components/controls/SelectList';
import { translate } from '../../../helpers/l10n';
+import { QualityGate } from '../../../types/types';
interface Props {
canEdit?: boolean;
- qualityGate: T.QualityGate;
+ qualityGate: QualityGate;
}
interface State {
searchUsers
} from '../../../api/quality-gates';
import { Group, isUser, SearchPermissionsParameters } from '../../../types/quality-gates';
+import { QualityGate, UserBase } from '../../../types/types';
import QualityGatePermissionsRenderer from './QualityGatePermissionsRenderer';
interface Props {
- qualityGate: T.QualityGate;
+ qualityGate: QualityGate;
}
interface State {
submitting: boolean;
loading: boolean;
showAddModal: boolean;
- permissionToDelete?: T.UserBase | Group;
- users: T.UserBase[];
+ permissionToDelete?: UserBase | Group;
+ users: UserBase[];
}
export default class QualityGatePermissions extends React.Component<Props, State> {
this.setState({ showAddModal: true });
};
- handleSubmitAddPermission = async (item: T.UserBase | Group) => {
+ handleSubmitAddPermission = async (item: UserBase | Group) => {
const { qualityGate } = this.props;
this.setState({ submitting: true });
this.setState({ permissionToDelete: undefined });
};
- handleClickDeletePermission = (permissionToDelete?: T.UserBase | Group) => {
+ handleClickDeletePermission = (permissionToDelete?: UserBase | Group) => {
this.setState({ permissionToDelete });
};
- handleConfirmDeletePermission = async (item: T.UserBase | Group) => {
+ handleConfirmDeletePermission = async (item: UserBase | Group) => {
const { qualityGate } = this.props;
let error = false;
import * as React from 'react';
import { searchGroups, searchUsers } from '../../../api/quality-gates';
import { Group, SearchPermissionsParameters } from '../../../types/quality-gates';
+import { QualityGate, UserBase } from '../../../types/types';
import QualityGatePermissionsAddModalRenderer from './QualityGatePermissionsAddModalRenderer';
interface Props {
onClose: () => void;
- onSubmit: (selection: T.UserBase | Group) => void;
- qualityGate: T.QualityGate;
+ onSubmit: (selection: UserBase | Group) => void;
+ qualityGate: QualityGate;
submitting: boolean;
}
interface State {
loading: boolean;
query?: string;
- searchResults: Array<T.UserBase | Group>;
- selection?: T.UserBase | Group;
+ searchResults: Array<UserBase | Group>;
+ selection?: UserBase | Group;
}
const DEBOUNCE_DELAY = 250;
}
};
- handleSelection = (selection: T.UserBase | Group) => {
+ handleSelection = (selection: UserBase | Group) => {
this.setState({ selection });
};
import Avatar from '../../../components/ui/Avatar';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { Group, isUser } from '../../../types/quality-gates';
+import { UserBase } from '../../../types/types';
export interface QualityGatePermissionsAddModalRendererProps {
onClose: () => void;
onInputChange: (query: string) => void;
onSubmit: (event: React.SyntheticEvent<HTMLFormElement>) => void;
- onSelection: (selection: T.UserBase | Group) => void;
+ onSelection: (selection: UserBase | Group) => void;
submitting: boolean;
loading: boolean;
query: string;
- searchResults: Array<T.UserBase | Group>;
- selection?: T.UserBase | Group;
+ searchResults: Array<UserBase | Group>;
+ selection?: UserBase | Group;
}
-type Option = (T.UserBase | Group) & { value: string };
+type Option = (UserBase | Group) & { value: string };
export default function QualityGatePermissionsAddModalRenderer(
props: QualityGatePermissionsAddModalRendererProps
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate } from '../../../helpers/l10n';
import { Group, isUser } from '../../../types/quality-gates';
+import { QualityGate, UserBase } from '../../../types/types';
import PermissionItem from './PermissionItem';
import QualityGatePermissionsAddModal from './QualityGatePermissionsAddModal';
loading: boolean;
onClickAddPermission: () => void;
onCloseAddPermission: () => void;
- onSubmitAddPermission: (item: T.UserBase | Group) => void;
+ onSubmitAddPermission: (item: UserBase | Group) => void;
onCloseDeletePermission: () => void;
- onConfirmDeletePermission: (item: T.UserBase | Group) => void;
- onClickDeletePermission: (item: T.UserBase | Group) => void;
- permissionToDelete?: T.UserBase | Group;
- qualityGate: T.QualityGate;
+ onConfirmDeletePermission: (item: UserBase | Group) => void;
+ onClickDeletePermission: (item: UserBase | Group) => void;
+ permissionToDelete?: UserBase | Group;
+ qualityGate: QualityGate;
showAddModal: boolean;
submitting: boolean;
- users: T.UserBase[];
+ users: UserBase[];
}
export default function QualityGatePermissionsRenderer(props: QualityGatePermissionsRendererProps) {
import MandatoryFieldMarker from '../../../components/ui/MandatoryFieldMarker';
import MandatoryFieldsExplanation from '../../../components/ui/MandatoryFieldsExplanation';
import { translate } from '../../../helpers/l10n';
+import { QualityGate } from '../../../types/types';
interface Props {
onClose: () => void;
onRename: () => Promise<void>;
- qualityGate: T.QualityGate;
+ qualityGate: QualityGate;
}
interface State {
*/
import * as React from 'react';
import SelectLegacy from '../../../components/controls/SelectLegacy';
+import { Metric } from '../../../types/types';
interface Props {
name: string;
value: string;
- metric: T.Metric;
+ metric: Metric;
onChange: (value: string) => void;
}
import { getLocalizedMetricName } from '../../helpers/l10n';
import { isDiffMetric } from '../../helpers/measures';
import { getMetricByKey } from '../../store/rootReducer';
+import { Condition, Metric, QualityGate } from '../../types/types';
-export function checkIfDefault(qualityGate: T.QualityGate, list: T.QualityGate[]): boolean {
+export function checkIfDefault(qualityGate: QualityGate, list: QualityGate[]): boolean {
const finding = list.find(candidate => candidate.id === qualityGate.id);
return (finding && finding.isDefault) || false;
}
-export function addCondition(qualityGate: T.QualityGate, condition: T.Condition): T.QualityGate {
+export function addCondition(qualityGate: QualityGate, condition: Condition): QualityGate {
const oldConditions = qualityGate.conditions || [];
const conditions = [...oldConditions, condition];
return { ...qualityGate, conditions };
}
-export function deleteCondition(qualityGate: T.QualityGate, condition: T.Condition): T.QualityGate {
+export function deleteCondition(qualityGate: QualityGate, condition: Condition): QualityGate {
const conditions =
qualityGate.conditions && qualityGate.conditions.filter(candidate => candidate !== condition);
return { ...qualityGate, conditions };
}
export function replaceCondition(
- qualityGate: T.QualityGate,
- newCondition: T.Condition,
- oldCondition: T.Condition
-): T.QualityGate {
+ qualityGate: QualityGate,
+ newCondition: Condition,
+ oldCondition: Condition
+): QualityGate {
const conditions =
qualityGate.conditions &&
qualityGate.conditions.map(candidate => {
return { ...qualityGate, conditions };
}
-export function getPossibleOperators(metric: T.Metric) {
+export function getPossibleOperators(metric: Metric) {
if (metric.direction === 1) {
return 'LT';
} else if (metric.direction === -1) {
return getMetricByKey(getStore().getState(), key) !== undefined;
}
-function getNoDiffMetric(metric: T.Metric) {
+function getNoDiffMetric(metric: Metric) {
const store = getStore().getState();
const regularMetricKey = metric.key.replace(/^new_/, '');
if (isDiffMetric(metric.key) && metricKeyExists(regularMetricKey)) {
}
}
-export function getLocalizedMetricNameNoDiffMetric(metric: T.Metric) {
+export function getLocalizedMetricNameNoDiffMetric(metric: Metric) {
return getLocalizedMetricName(getNoDiffMetric(metric));
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { Dict } from '../../../types/types';
import ParameterChange from './ParameterChange';
import SeverityChange from './SeverityChange';
interface Props {
- changes: T.Dict<string | null>;
+ changes: Dict<string | null>;
}
export default function ChangesList({ changes }: Props) {
import { lazyLoadComponent } from '../../../components/lazyLoadComponent';
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate } from '../../../helpers/l10n';
+import { RuleDetails } from '../../../types/types';
const ActivationFormModal = lazyLoadComponent(
() => import('../../coding-rules/components/ActivationFormModal'),
}
interface State {
- rule?: T.RuleDetails;
+ rule?: RuleDetails;
state: 'closed' | 'opening' | 'open';
}
this.setState({ state: 'closed' });
};
- isOpen(state: State): state is { state: 'open'; rule: T.RuleDetails } {
+ isOpen(state: State): state is { state: 'open'; rule: RuleDetails } {
return state.state === 'open';
}
import SeverityIcon from '../../../components/icons/SeverityIcon';
import { translateWithParameters } from '../../../helpers/l10n';
import { getRulesUrl } from '../../../helpers/urls';
+import { Dict } from '../../../types/types';
import ComparisonEmpty from './ComparisonEmpty';
import ComparisonResultActivation from './ComparisonResultActivation';
-type Params = T.Dict<string>;
+type Params = Dict<string>;
interface Props extends CompareResponse {
leftProfile: Profile;
import { Actions, getExporters, searchQualityProfiles } from '../../../api/quality-profiles';
import Suggestions from '../../../app/components/embed-docs-modal/Suggestions';
import { translate } from '../../../helpers/l10n';
+import { Languages } from '../../../types/types';
import '../styles.css';
import { Exporter, Profile } from '../types';
import { sortProfiles } from '../utils';
interface Props {
children: React.ReactElement<any>;
- languages: T.Languages;
+ languages: Languages;
}
interface State {
import { getProfileInheritance } from '../../../api/quality-profiles';
import { Button } from '../../../components/controls/buttons';
import { translate } from '../../../helpers/l10n';
+import { ProfileInheritanceDetails } from '../../../types/types';
import { Profile } from '../types';
import ChangeParentForm from './ChangeParentForm';
import ProfileInheritanceBox from './ProfileInheritanceBox';
}
interface State {
- ancestors?: T.ProfileInheritanceDetails[];
- children?: T.ProfileInheritanceDetails[];
+ ancestors?: ProfileInheritanceDetails[];
+ children?: ProfileInheritanceDetails[];
formOpen: boolean;
loading: boolean;
- profile?: T.ProfileInheritanceDetails;
+ profile?: ProfileInheritanceDetails;
}
export default class ProfileInheritance extends React.PureComponent<Props, State> {
import * as React from 'react';
import HelpTooltip from '../../../components/controls/HelpTooltip';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { ProfileInheritanceDetails } from '../../../types/types';
import BuiltInQualityProfileBadge from '../components/BuiltInQualityProfileBadge';
import ProfileLink from '../components/ProfileLink';
displayLink?: boolean;
extendsBuiltIn?: boolean;
language: string;
- profile: T.ProfileInheritanceDetails;
+ profile: ProfileInheritanceDetails;
type?: string;
}
} from '../../../api/quality-profiles';
import { Button } from '../../../components/controls/buttons';
import { translate } from '../../../helpers/l10n';
+import { UserSelected } from '../../../types/types';
import { Profile } from '../types';
import ProfilePermissionsForm from './ProfilePermissionsForm';
import ProfilePermissionsGroup from './ProfilePermissionsGroup';
addUserForm: boolean;
groups?: Group[];
loading: boolean;
- users?: T.UserSelected[];
+ users?: UserSelected[];
}
export default class ProfilePermissions extends React.PureComponent<Props, State> {
}
};
- handleUserAdd = (addedUser: T.UserSelected) => {
+ handleUserAdd = (addedUser: UserSelected) => {
if (this.mounted) {
this.setState((state: State) => ({
addUserForm: false,
}
};
- handleUserDelete = (removedUser: T.UserSelected) => {
+ handleUserDelete = (removedUser: UserSelected) => {
if (this.mounted) {
this.setState((state: State) => ({
users: state.users && state.users.filter(user => user !== removedUser)
}
};
- handleGroupAdd = (addedGroup: T.Group) => {
+ handleGroupAdd = (addedGroup: Group) => {
if (this.mounted) {
this.setState((state: State) => ({
addUserForm: false,
}
};
- handleGroupDelete = (removedGroup: T.Group) => {
+ handleGroupDelete = (removedGroup: Group) => {
if (this.mounted) {
this.setState((state: State) => ({
groups: state.groups && state.groups.filter(group => group !== removedGroup)
import { ResetButtonLink, SubmitButton } from '../../../components/controls/buttons';
import Modal from '../../../components/controls/Modal';
import { translate } from '../../../helpers/l10n';
+import { UserSelected } from '../../../types/types';
import { Group } from './ProfilePermissions';
import ProfilePermissionsFormSelect from './ProfilePermissionsFormSelect';
interface Props {
onClose: () => void;
onGroupAdd: (group: Group) => void;
- onUserAdd: (user: T.UserSelected) => void;
+ onUserAdd: (user: UserSelected) => void;
profile: { language: string; name: string };
}
interface State {
- selected?: T.UserSelected | Group;
+ selected?: UserSelected | Group;
submitting: boolean;
}
}
};
- handleUserAdd = (user: T.UserSelected) => {
+ handleUserAdd = (user: UserSelected) => {
const {
profile: { language, name }
} = this.props;
const { selected } = this.state;
if (selected) {
this.setState({ submitting: true });
- if ((selected as T.UserSelected).login !== undefined) {
- this.handleUserAdd(selected as T.UserSelected);
+ if ((selected as UserSelected).login !== undefined) {
+ this.handleUserAdd(selected as UserSelected);
} else {
this.handleGroupAdd(selected as Group);
}
]);
};
- handleValueChange = (selected: T.UserSelected | Group) => {
+ handleValueChange = (selected: UserSelected | Group) => {
this.setState({ selected });
};
import GroupIcon from '../../../components/icons/GroupIcon';
import Avatar from '../../../components/ui/Avatar';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { UserSelected } from '../../../types/types';
import { Group } from './ProfilePermissions';
-type Option = T.UserSelected | Group;
+type Option = UserSelected | Group;
type OptionWithValue = Option & { value: string };
interface Props {
}
}
-function isUser(option: Option): option is T.UserSelected {
- return (option as T.UserSelected).login !== undefined;
+function isUser(option: Option): option is UserSelected {
+ return (option as UserSelected).login !== undefined;
}
function getStringValue(option: Option) {
import SimpleModal, { ChildrenProps } from '../../../components/controls/SimpleModal';
import Avatar from '../../../components/ui/Avatar';
import { translate } from '../../../helpers/l10n';
+import { UserSelected } from '../../../types/types';
interface Props {
- onDelete: (user: T.UserSelected) => void;
+ onDelete: (user: UserSelected) => void;
profile: { language: string; name: string };
- user: T.UserSelected;
+ user: UserSelected;
}
interface State {
import Tooltip from '../../../components/controls/Tooltip';
import { translate } from '../../../helpers/l10n';
import { getRulesUrl } from '../../../helpers/urls';
+import { Dict } from '../../../types/types';
import { Profile } from '../types';
import ProfileRulesDeprecatedWarning from './ProfileRulesDeprecatedWarning';
import ProfileRulesRowOfType from './ProfileRulesRowOfType';
interface State {
activatedTotal: number | null;
- activatedByType: T.Dict<ByType>;
- allByType: T.Dict<ByType>;
+ activatedByType: Dict<ByType>;
+ allByType: Dict<ByType>;
compareToSonarWay: { profile: string; profileName: string; missingRuleCount: number } | null;
total: number | null;
}
import { addGroup, addUser, searchGroups, searchUsers } from '../../../../api/quality-profiles';
import { mockGroup, mockUser } from '../../../../helpers/testMocks';
import { submit, waitAndUpdate } from '../../../../helpers/testUtils';
+import { UserSelected } from '../../../../types/types';
import ProfilePermissionsForm from '../ProfilePermissionsForm';
import ProfilePermissionsFormSelect from '../ProfilePermissionsFormSelect';
const onUserAdd = jest.fn();
const wrapper = shallowRender({ onUserAdd });
- const user: T.UserSelected = { ...mockUser(), name: 'John doe', active: true, selected: true };
+ const user: UserSelected = { ...mockUser(), name: 'John doe', active: true, selected: true };
wrapper.instance().handleValueChange(user);
expect(wrapper.find(ProfilePermissionsFormSelect).prop('selected')).toBe(user);
import * as React from 'react';
import { removeUser } from '../../../../api/quality-profiles';
import { click } from '../../../../helpers/testUtils';
+import { UserSelected } from '../../../../types/types';
import ProfilePermissionsUser from '../ProfilePermissionsUser';
jest.mock('../../../../api/quality-profiles', () => ({
}));
const profile = { language: 'js', name: 'Sonar way' };
-const user: T.UserSelected = { login: 'luke', name: 'Luke Skywalker', selected: true };
+const user: UserSelected = { login: 'luke', name: 'Luke Skywalker', selected: true };
beforeEach(() => {
jest.clearAllMocks();
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { formatMeasure } from '../../../helpers/measures';
import { getRulesUrl } from '../../../helpers/urls';
+import { Dict, Rule, RuleActivation } from '../../../types/types';
const RULES_LIMIT = 10;
-function parseRules(rules: T.Rule[], actives?: T.Dict<T.RuleActivation[]>): ExtendedRule[] {
+function parseRules(rules: Rule[], actives?: Dict<RuleActivation[]>): ExtendedRule[] {
return rules.map(rule => {
const activations = actives && actives[rule.key];
return { ...rule, activations: activations ? activations.length : 0 };
});
}
-interface ExtendedRule extends T.Rule {
+interface ExtendedRule extends Rule {
activations: number;
}
import HelpTooltip from '../../../components/controls/HelpTooltip';
import { Alert } from '../../../components/ui/Alert';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Dict, Language } from '../../../types/types';
import { Profile } from '../types';
import ProfilesListHeader from './ProfilesListHeader';
import ProfilesListRow from './ProfilesListRow';
interface Props {
- languages: T.Language[];
+ languages: Language[];
location: Pick<Location, 'query'>;
profiles: Profile[];
updateProfiles: () => Promise<void>;
const { profiles, languages } = this.props;
const { language } = this.props.location.query;
- const profilesIndex: T.Dict<Profile[]> = groupBy<Profile>(
- profiles,
- profile => profile.language
- );
+ const profilesIndex: Dict<Profile[]> = groupBy<Profile>(profiles, profile => profile.language);
const profilesToShow = language ? pick(profilesIndex, language) : profilesIndex;
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { Profile as BaseProfile } from '../../api/quality-profiles';
+import { Dict } from '../../types/types';
export interface Profile extends BaseProfile {
depth: number;
action: string;
authorName: string;
date: string;
- params?: T.Dict<string | null>;
+ params?: Dict<string | null>;
ruleKey: string;
ruleName: string;
}
HotspotStatusFilter,
RawHotspot
} from '../../types/security-hotspots';
+import { Component, CurrentUser, Dict } from '../../types/types';
import SecurityHotspotsAppRenderer from './SecurityHotspotsAppRenderer';
import './styles.css';
import { SECURITY_STANDARDS } from './utils';
interface OwnProps {
branchLike?: BranchLike;
- currentUser: T.CurrentUser;
- component: T.Component;
+ currentUser: CurrentUser;
+ component: Component;
location: Location;
router: Router;
}
}
if (filterByCategory || filterByCWE || filterByFile) {
- const hotspotFilters: T.Dict<string> = {};
+ const hotspotFilters: Dict<string> = {};
if (filterByCategory) {
hotspotFilters[filterByCategory.standard] = filterByCategory.category;
import { BranchLike } from '../../types/branch-like';
import { SecurityStandard, Standards } from '../../types/security';
import { HotspotFilters, HotspotStatusFilter, RawHotspot } from '../../types/security-hotspots';
+import { Component, StandardSecurityCategories } from '../../types/types';
import EmptyHotspotsPage from './components/EmptyHotspotsPage';
import FilterBar from './components/FilterBar';
import HotspotList from './components/HotspotList';
export interface SecurityHotspotsAppRendererProps {
branchLike?: BranchLike;
- component: T.Component;
+ component: Component;
filterByCategory?: {
standard: SecurityStandard;
category: string;
onSwitchStatusFilter: (option: HotspotStatusFilter) => void;
onUpdateHotspot: (hotspotKey: string) => Promise<void>;
selectedHotspot: RawHotspot | undefined;
- securityCategories: T.StandardSecurityCategories;
+ securityCategories: StandardSecurityCategories;
standards: Standards;
}
ReviewHistoryType,
RiskExposure
} from '../../../types/security-hotspots';
+import { IssueChangelog } from '../../../types/types';
import {
getHotspotReviewHistory,
getStatusAndResolutionFromStatusOption,
describe('getHotspotReviewHistory', () => {
it('should properly create the review history', () => {
- const changelogElement: T.IssueChangelog = {
+ const changelogElement: IssueChangelog = {
creationDate: '2018-10-01',
isUserActive: true,
user: 'me',
import { isLoggedIn } from '../../../helpers/users';
import { ComponentQualifier } from '../../../types/component';
import { HotspotFilters, HotspotStatusFilter } from '../../../types/security-hotspots';
+import { Component, CurrentUser } from '../../../types/types';
export interface FilterBarProps {
- currentUser: T.CurrentUser;
- component: T.Component;
+ currentUser: CurrentUser;
+ component: Component;
filters: HotspotFilters;
hotspotsReviewedMeasure?: string;
isStaticListOfHotspots: boolean;
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { addSideBarClass, removeSideBarClass } from '../../../helpers/pages';
import { HotspotStatusFilter, RawHotspot, RiskExposure } from '../../../types/security-hotspots';
+import { Dict, StandardSecurityCategories } from '../../../types/types';
import { groupByCategory, RISK_EXPOSURE_LEVELS } from '../utils';
import HotspotCategory from './HotspotCategory';
import './HotspotList.css';
loadingMore: boolean;
onHotspotClick: (hotspot: RawHotspot) => void;
onLoadMore: () => void;
- securityCategories: T.StandardSecurityCategories;
+ securityCategories: StandardSecurityCategories;
selectedHotspot: RawHotspot;
statusFilter: HotspotStatusFilter;
}
interface State {
- expandedCategories: T.Dict<boolean>;
+ expandedCategories: Dict<boolean>;
groupedHotspots: Array<{
risk: RiskExposure;
categories: Array<{ key: string; hotspots: RawHotspot[]; title: string }>;
removeSideBarClass();
}
- groupHotspots = (hotspots: RawHotspot[], securityCategories: T.StandardSecurityCategories) => {
+ groupHotspots = (hotspots: RawHotspot[], securityCategories: StandardSecurityCategories) => {
const risks = groupBy(hotspots, h => h.vulnerabilityProbability);
return RISK_EXPOSURE_LEVELS.map(risk => ({
import { translate } from '../../../helpers/l10n';
import { isLoggedIn } from '../../../helpers/users';
import { Hotspot } from '../../../types/security-hotspots';
+import { CurrentUser } from '../../../types/types';
import HotspotReviewHistory from './HotspotReviewHistory';
interface Props {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
hotspot: Hotspot;
commentTextRef: React.RefObject<HTMLTextAreaElement>;
onCommentUpdate: () => void;
import { BranchLike } from '../../../types/branch-like';
import { ComponentQualifier } from '../../../types/component';
import { Hotspot } from '../../../types/security-hotspots';
+import { Component, ExpandDirection, SourceLine } from '../../../types/types';
import { constructSourceViewerFile } from '../utils';
import HotspotSnippetContainerRenderer from './HotspotSnippetContainerRenderer';
interface Props {
branchLike?: BranchLike;
- component: T.Component;
+ component: Component;
hotspot: Hotspot;
}
highlightedSymbols: string[];
lastLine?: number;
loading: boolean;
- sourceLines: T.SourceLine[];
+ sourceLines: SourceLine[];
}
const BUFFER_LINES = 5;
this.mounted = false;
}
- checkLastLine(lines: T.SourceLine[], target: number): number | undefined {
+ checkLastLine(lines: SourceLine[], target: number): number | undefined {
if (lines.length < 1) {
return undefined;
}
from,
to,
...getBranchLikeQuery(branchLike)
- }).catch(() => [] as T.SourceLine[]);
+ }).catch(() => [] as SourceLine[]);
if (this.mounted) {
const lastLine = this.checkLastLine(sourceLines, to);
}
}
- handleExpansion = (direction: T.ExpandDirection) => {
+ handleExpansion = (direction: ExpandDirection) => {
const { branchLike, hotspot } = this.props;
const { sourceLines } = this.state;
import { translate } from '../../../helpers/l10n';
import { BranchLike } from '../../../types/branch-like';
import { Hotspot } from '../../../types/security-hotspots';
+import {
+ ExpandDirection,
+ LinearIssueLocation,
+ SourceLine,
+ SourceViewerFile
+} from '../../../types/types';
import SnippetViewer from '../../issues/crossComponentSourceViewer/SnippetViewer';
export interface HotspotSnippetContainerRendererProps {
highlightedSymbols: string[];
hotspot: Hotspot;
loading: boolean;
- locations: { [line: number]: T.LinearIssueLocation[] };
- onExpandBlock: (direction: T.ExpandDirection) => Promise<void>;
+ locations: { [line: number]: LinearIssueLocation[] };
+ onExpandBlock: (direction: ExpandDirection) => Promise<void>;
onSymbolClick: (symbols: string[]) => void;
- sourceLines: T.SourceLine[];
- sourceViewerFile: T.SourceViewerFile;
+ sourceLines: SourceLine[];
+ sourceViewerFile: SourceViewerFile;
}
const noop = () => undefined;
HotspotStatusFilter,
HotspotStatusOption
} from '../../../types/security-hotspots';
+import { Component, StandardSecurityCategories } from '../../../types/types';
import { getStatusFilterFromStatusOption } from '../utils';
import HotspotViewerRenderer from './HotspotViewerRenderer';
interface Props {
branchLike?: BranchLike;
- component: T.Component;
+ component: Component;
hotspotKey: string;
hotspotsReviewedMeasure?: string;
onSwitchStatusFilter: (option: HotspotStatusFilter) => void;
onUpdateHotspot: (hotspotKey: string) => Promise<void>;
- securityCategories: T.StandardSecurityCategories;
+ securityCategories: StandardSecurityCategories;
}
interface State {
import { isLoggedIn } from '../../../helpers/users';
import { BranchLike } from '../../../types/branch-like';
import { Hotspot, HotspotStatusOption } from '../../../types/security-hotspots';
+import { Component, CurrentUser, StandardSecurityCategories } from '../../../types/types';
import Assignee from './assignee/Assignee';
import HotspotOpenInIdeButton from './HotspotOpenInIdeButton';
import HotspotReviewHistoryAndComments from './HotspotReviewHistoryAndComments';
export interface HotspotViewerRendererProps {
branchLike?: BranchLike;
- component: T.Component;
- currentUser: T.CurrentUser;
+ component: Component;
+ currentUser: CurrentUser;
hotspot?: Hotspot;
hotspotsReviewedMeasure?: string;
lastStatusChangedTo?: HotspotStatusOption;
onShowCommentForm: () => void;
onSwitchFilterToStatusOfUpdatedHotspot: () => void;
showStatusUpdateSuccessModal: boolean;
- securityCategories: T.StandardSecurityCategories;
+ securityCategories: StandardSecurityCategories;
}
export function HotspotViewerRenderer(props: HotspotViewerRendererProps) {
import { translate, translateWithParameters } from '../../../../helpers/l10n';
import { isLoggedIn } from '../../../../helpers/users';
import { Hotspot, HotspotStatus } from '../../../../types/security-hotspots';
+import { CurrentUser, UserActive } from '../../../../types/types';
import AssigneeRenderer from './AssigneeRenderer';
interface Props {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
hotspot: Hotspot;
onAssigneeChange: () => void;
this.setState({ editing: false });
};
- handleAssign = (newAssignee: T.UserActive) => {
+ handleAssign = (newAssignee: UserActive) => {
this.setState({ loading: true });
assignSecurityHotspot(this.props.hotspot.key, {
assignee: newAssignee?.login
import OutsideClickHandler from '../../../../components/controls/OutsideClickHandler';
import DeferredSpinner from '../../../../components/ui/DeferredSpinner';
import { translate, translateWithParameters } from '../../../../helpers/l10n';
+import { LoggedInUser, UserActive, UserBase } from '../../../../types/types';
import AssigneeSelection from './AssigneeSelection';
export interface AssigneeRendererProps {
editing: boolean;
loading: boolean;
- assignee?: T.UserBase;
- loggedInUser?: T.LoggedInUser;
+ assignee?: UserBase;
+ loggedInUser?: LoggedInUser;
- onAssign: (user: T.UserActive) => void;
+ onAssign: (user: UserActive) => void;
onEnterEditionMode: () => void;
onExitEditionMode: () => void;
}
import { KeyboardCodes } from '../../../../helpers/keycodes';
import { translate } from '../../../../helpers/l10n';
import { isUserActive } from '../../../../helpers/users';
+import { LoggedInUser, UserActive } from '../../../../types/types';
import AssigneeSelectionRenderer from './AssigneeSelectionRenderer';
interface Props {
allowCurrentUserSelection: boolean;
- loggedInUser: T.LoggedInUser;
- onSelect: (user: T.UserActive) => void;
+ loggedInUser: LoggedInUser;
+ onSelect: (user: UserActive) => void;
}
interface State {
- highlighted?: T.UserActive;
+ highlighted?: UserActive;
loading: boolean;
query?: string;
- suggestedUsers: T.UserActive[];
+ suggestedUsers: UserActive[];
}
-const UNASSIGNED: T.UserActive = { login: '', name: translate('unassigned') };
+const UNASSIGNED: UserActive = { login: '', name: translate('unassigned') };
export default class AssigneeSelection extends React.PureComponent<Props, State> {
mounted = false;
this.setState({
loading: false,
query,
- suggestedUsers: (result.users.filter(isUserActive) as T.UserActive[]).concat(UNASSIGNED)
+ suggestedUsers: (result.users.filter(isUserActive) as UserActive[]).concat(UNASSIGNED)
});
}
})
import DeferredSpinner from '../../../../components/ui/DeferredSpinner';
import { PopupPlacement } from '../../../../components/ui/popups';
import { translate } from '../../../../helpers/l10n';
+import { UserActive } from '../../../../types/types';
import './AssigneeSelection.css';
export interface HotspotAssigneeSelectRendererProps {
- highlighted?: T.UserActive;
+ highlighted?: UserActive;
loading: boolean;
onKeyDown: (event: React.KeyboardEvent) => void;
onSearch: (query: string) => void;
- onSelect: (user?: T.UserActive) => void;
+ onSelect: (user?: UserActive) => void;
query?: string;
- suggestedUsers?: T.UserActive[];
+ suggestedUsers?: UserActive[];
}
export default function AssigneeSelectionRenderer(props: HotspotAssigneeSelectRendererProps) {
import { mockCurrentUser, mockUser } from '../../../../../helpers/testMocks';
import { waitAndUpdate } from '../../../../../helpers/testUtils';
import { HotspotStatus } from '../../../../../types/security-hotspots';
+import { UserActive } from '../../../../../types/types';
import { Assignee } from '../Assignee';
import AssigneeRenderer from '../AssigneeRenderer';
});
it.each([
- ['assign to user', mockUser() as T.UserActive],
- ['unassign', { login: '', name: 'unassigned' } as T.UserActive]
-])('should handle %s event', async (_, user: T.UserActive) => {
+ ['assign to user', mockUser() as UserActive],
+ ['unassign', { login: '', name: 'unassigned' } as UserActive]
+])('should handle %s event', async (_, user: UserActive) => {
const hotspot = mockHotspot();
const onAssigneeChange = jest.fn();
import OutsideClickHandler from '../../../../../components/controls/OutsideClickHandler';
import { mockLoggedInUser, mockUser } from '../../../../../helpers/testMocks';
import { click } from '../../../../../helpers/testUtils';
+import { UserActive } from '../../../../../types/types';
import AssigneeRenderer, { AssigneeRendererProps } from '../AssigneeRenderer';
import AssigneeSelection from '../AssigneeSelection';
wrapper
.find(AssigneeSelection)
.props()
- .onSelect(newAssignee as T.UserActive);
+ .onSelect(newAssignee as UserActive);
expect(onAssign).toHaveBeenCalledWith(newAssignee);
wrapper
import { KeyboardCodes } from '../../../../../helpers/keycodes';
import { mockLoggedInUser, mockUser } from '../../../../../helpers/testMocks';
import { waitAndUpdate } from '../../../../../helpers/testUtils';
+import { UserActive } from '../../../../../types/types';
import AssigneeSelection from '../AssigneeSelection';
jest.mock('../../../../../api/users', () => ({
it('should handle keydown', () => {
const mockEvent = (code: KeyboardCodes) => ({ preventDefault: jest.fn(), nativeEvent: { code } });
const suggestedUsers = [
- mockUser({ login: '1' }) as T.UserActive,
- mockUser({ login: '2' }) as T.UserActive,
- mockUser({ login: '3' }) as T.UserActive
+ mockUser({ login: '1' }) as UserActive,
+ mockUser({ login: '2' }) as UserActive,
+ mockUser({ login: '3' }) as UserActive
];
const onSelect = jest.fn();
import { shallow } from 'enzyme';
import * as React from 'react';
import { mockUser } from '../../../../../helpers/testMocks';
+import { UserActive } from '../../../../../types/types';
import AssigneeSelectionRenderer, {
HotspotAssigneeSelectRendererProps
} from '../AssigneeSelectionRenderer';
expect(shallowRender()).toMatchSnapshot();
expect(shallowRender({ loading: true })).toMatchSnapshot('loading');
- const highlightedUser = mockUser({ login: 'highlighted' }) as T.UserActive;
+ const highlightedUser = mockUser({ login: 'highlighted' }) as UserActive;
expect(
shallowRender({
highlighted: highlightedUser,
- suggestedUsers: [mockUser() as T.UserActive, highlightedUser]
+ suggestedUsers: [mockUser() as UserActive, highlightedUser]
})
).toMatchSnapshot('open with results');
});
it('should call onSelect when clicked', () => {
- const user = mockUser() as T.UserActive;
+ const user = mockUser() as UserActive;
const onSelect = jest.fn();
const wrapper = shallowRender({
onSelect,
import { translate } from '../../../../helpers/l10n';
import { isLoggedIn } from '../../../../helpers/users';
import { Hotspot, HotspotStatusOption } from '../../../../types/security-hotspots';
+import { CurrentUser } from '../../../../types/types';
import { getStatusOptionFromStatusAndResolution } from '../../utils';
import StatusDescription from './StatusDescription';
import StatusSelection from './StatusSelection';
export interface StatusProps {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
hotspot: Hotspot;
onStatusChange: (statusOption: HotspotStatusOption) => Promise<void>;
ReviewHistoryType,
RiskExposure
} from '../../types/security-hotspots';
+import { Dict, SourceViewerFile, StandardSecurityCategories } from '../../types/types';
export const RISK_EXPOSURE_LEVELS = [RiskExposure.HIGH, RiskExposure.MEDIUM, RiskExposure.LOW];
export const SECURITY_STANDARDS = [
[SecurityStandard.CWE]: renderCWECategory
};
-export function mapRules(rules: Array<{ key: string; name: string }>): T.Dict<string> {
- return rules.reduce((ruleMap: T.Dict<string>, r) => {
+export function mapRules(rules: Array<{ key: string; name: string }>): Dict<string> {
+ return rules.reduce((ruleMap: Dict<string>, r) => {
ruleMap[r.key] = r.name;
return ruleMap;
}, {});
export function groupByCategory(
hotspots: RawHotspot[] = [],
- securityCategories: T.StandardSecurityCategories
+ securityCategories: StandardSecurityCategories
) {
const groups = groupBy(hotspots, h => h.securityCategory);
}));
}
-export function sortHotspots(
- hotspots: RawHotspot[],
- securityCategories: T.Dict<{ title: string }>
-) {
+export function sortHotspots(hotspots: RawHotspot[], securityCategories: Dict<{ title: string }>) {
return sortBy(hotspots, [
h => RISK_EXPOSURE_LEVELS.indexOf(h.vulnerabilityProbability),
h => getCategoryTitle(h.securityCategory, securityCategories),
]);
}
-function getCategoryTitle(key: string, securityCategories: T.StandardSecurityCategories) {
+function getCategoryTitle(key: string, securityCategories: StandardSecurityCategories) {
return securityCategories[key] ? securityCategories[key].title : key;
}
export function constructSourceViewerFile(
{ component, project }: Hotspot,
lines?: number
-): T.SourceViewerFile {
+): SourceViewerFile {
return {
key: component.key,
measures: { lines: lines ? lines.toString() : undefined },
import { Alert } from '../../../components/ui/Alert';
import { translate } from '../../../helpers/l10n';
import { Store } from '../../../store/rootReducer';
+import { IdentityProvider } from '../../../types/types';
import './Login.css';
import LoginForm from './LoginForm';
import OAuthProviders from './OAuthProviders';
export interface LoginProps {
authorizationError?: boolean;
authenticationError?: boolean;
- identityProviders: T.IdentityProvider[];
+ identityProviders: IdentityProvider[];
onSubmit: (login: string, password: string) => Promise<void>;
returnTo: string;
}
import { getIdentityProviders } from '../../../api/users';
import { getReturnUrl } from '../../../helpers/urls';
import { doLogin } from '../../../store/rootActions';
+import { IdentityProvider } from '../../../types/types';
import Login from './Login';
interface OwnProps {
type Props = OwnProps & DispatchToProps;
interface State {
- identityProviders?: T.IdentityProvider[];
+ identityProviders?: IdentityProvider[];
}
export class LoginContainer extends React.PureComponent<Props, State> {
import IdentityProviderLink from '../../../components/controls/IdentityProviderLink';
import { translateWithParameters } from '../../../helpers/l10n';
import { getBaseUrl } from '../../../helpers/system';
+import { IdentityProvider } from '../../../types/types';
import './OAuthProviders.css';
interface Props {
className?: string;
formatLabel?: (name: string) => React.ReactNode;
- identityProviders: T.IdentityProvider[];
+ identityProviders: IdentityProvider[];
returnTo: string;
}
interface ItemProps {
format: (name: string) => React.ReactNode;
- identityProvider: T.IdentityProvider;
+ identityProvider: IdentityProvider;
returnTo: string;
}
*/
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { Component } from '../../../types/types';
import {
ALM_INTEGRATION,
ANALYSIS_SCOPE_CATEGORY,
import PullRequestDecorationBinding from './pullRequestDecorationBinding/PRDecorationBinding';
export interface AdditionalCategoryComponentProps {
- component: T.Component | undefined;
+ component: Component | undefined;
selectedCategory: string;
}
import { IndexLink } from 'react-router';
import { getGlobalSettingsUrl, getProjectSettingsUrl } from '../../../helpers/urls';
import { getAppState, getSettingsAppAllCategories, Store } from '../../../store/rootReducer';
+import { Component } from '../../../types/types';
import { getCategoryName } from '../utils';
import { ADDITIONAL_CATEGORIES } from './AdditionalCategories';
import CATEGORY_OVERRIDES from './CategoryOverrides';
export interface CategoriesListProps {
branchesEnabled?: boolean;
categories: string[];
- component?: T.Component;
+ component?: Component;
defaultCategory: string;
selectedCategory: string;
}
*/
import { connect } from 'react-redux';
import { getSettingsAppSettingsForCategory, Store } from '../../../store/rootReducer';
+import { Component } from '../../../types/types';
import { fetchValues } from '../store/actions';
import SubCategoryDefinitionsList from './SubCategoryDefinitionsList';
interface Props {
category: string;
- component?: T.Component;
+ component?: Component;
}
const mapStateToProps = (state: Store, ownProps: Props) => ({
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+import { Dict } from '../../../types/types';
import { LANGUAGES_CATEGORY } from './AdditionalCategoryKeys';
-const CATEGORY_OVERRIDES: T.Dict<string> = {
+const CATEGORY_OVERRIDES: Dict<string> = {
abap: LANGUAGES_CATEGORY,
apex: LANGUAGES_CATEGORY,
'c / c++ / objective-c': LANGUAGES_CATEGORY,
Store
} from '../../../store/rootReducer';
import { Setting } from '../../../types/settings';
+import { Component } from '../../../types/types';
import { checkValue, resetValue, saveValue } from '../store/actions';
import { cancelChange, changeValue, passValidation } from '../store/settingsPage';
import {
changeValue: (key: string, value: any) => void;
changedValue: any;
checkValue: (key: string) => boolean;
- component?: T.Component;
+ component?: Component;
loading: boolean;
passValidation: (key: string) => void;
resetValue: (key: string, component?: string) => Promise<void>;
*/
import * as React from 'react';
import { Setting } from '../../../types/settings';
+import { Component } from '../../../types/types';
import Definition from './Definition';
interface Props {
- component?: T.Component;
+ component?: Component;
scrollToDefinition: (element: HTMLLIElement) => void;
settings: Setting[];
}
import MandatoryFieldsExplanation from '../../../components/ui/MandatoryFieldsExplanation';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { parseError } from '../../../helpers/request';
+import { LoggedInUser } from '../../../types/types';
interface Props {
- currentUser: T.LoggedInUser;
+ currentUser: LoggedInUser;
}
interface State {
import AlertSuccessIcon from '../../../components/icons/AlertSuccessIcon';
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate } from '../../../helpers/l10n';
+import { NewCodePeriodSettingType } from '../../../types/types';
import BaselineSettingDays from '../../projectBaseline/components/BaselineSettingDays';
import BaselineSettingPreviousVersion from '../../projectBaseline/components/BaselineSettingPreviousVersion';
import { validateDays } from '../../projectBaseline/utils';
interface State {
- currentSetting?: T.NewCodePeriodSettingType;
+ currentSetting?: NewCodePeriodSettingType;
days: string;
loading: boolean;
currentSettingValue?: string | number;
saving: boolean;
- selected?: T.NewCodePeriodSettingType;
+ selected?: NewCodePeriodSettingType;
success: boolean;
}
this.setState({ days, success: false });
};
- onSelectSetting = (selected: T.NewCodePeriodSettingType) => {
+ onSelectSetting = (selected: NewCodePeriodSettingType) => {
this.setState({ selected, success: false });
};
import * as React from 'react';
import InstanceMessage from '../../../components/common/InstanceMessage';
import { translate } from '../../../helpers/l10n';
+import { Component } from '../../../types/types';
import SettingsSearch from './SettingsSearch';
export interface PageHeaderProps {
- component?: T.Component;
+ component?: Component;
}
export default function PageHeader({ component }: PageHeaderProps) {
removeWhitePageClass
} from '../../../helpers/pages';
import { getSettingsAppDefaultCategory, Store } from '../../../store/rootReducer';
+import { Component } from '../../../types/types';
import { fetchSettings } from '../store/actions';
import '../styles.css';
import { ADDITIONAL_CATEGORIES } from './AdditionalCategories';
import PageHeader from './PageHeader';
interface Props {
- component?: T.Component;
+ component?: Component;
defaultCategory: string;
fetchSettings(component?: string): Promise<void>;
}
import { KeyboardCodes } from '../../../helpers/keycodes';
import { getSettingsAppAllDefinitions, Store } from '../../../store/rootReducer';
import { SettingCategoryDefinition } from '../../../types/settings';
+import { Component, Dict } from '../../../types/types';
import {
ADDITIONAL_PROJECT_SETTING_DEFINITIONS,
ADDITIONAL_SETTING_DEFINITIONS,
interface Props {
className?: string;
- component?: T.Component;
+ component?: Component;
definitions: SettingCategoryDefinition[];
router: InjectedRouter;
}
const DEBOUNCE_DELAY = 250;
export class SettingsSearch extends React.Component<Props, State> {
- definitionsByKey: T.Dict<SettingCategoryDefinition>;
+ definitionsByKey: Dict<SettingCategoryDefinition>;
index: LunrIndex;
state: State = {
searchQuery: '',
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { scrollToElement } from '../../../helpers/scrolling';
import { SettingCategoryDefinition } from '../../../types/settings';
+import { Component } from '../../../types/types';
import { buildSettingLink, isRealSettingKey } from '../utils';
export interface SettingsSearchRendererProps {
className?: string;
- component?: T.Component;
+ component?: Component;
results?: SettingCategoryDefinition[];
searchQuery: string;
selectedResult?: string;
import { sanitizeStringRestricted } from '../../../helpers/sanitize';
import { scrollToElement } from '../../../helpers/scrolling';
import { SettingWithCategory } from '../../../types/settings';
+import { Component } from '../../../types/types';
import { getSubCategoryDescription, getSubCategoryName } from '../utils';
import DefinitionsList from './DefinitionsList';
import EmailForm from './EmailForm';
export interface SubCategoryDefinitionsListProps {
category: string;
- component?: T.Component;
+ component?: Component;
fetchValues: Function;
location: Location;
settings: Array<SettingWithCategory>;
AlmSettingsBindingStatus,
AlmSettingsBindingStatusType
} from '../../../../types/alm-settings';
+import { AppState, Dict } from '../../../../types/types';
import AlmIntegrationRenderer from './AlmIntegrationRenderer';
interface Props extends Pick<WithRouterProps, 'location' | 'router'> {
- appState: Pick<T.AppState, 'branchesEnabled' | 'multipleAlmEnabled'>;
+ appState: Pick<AppState, 'branchesEnabled' | 'multipleAlmEnabled'>;
}
export type AlmTabs = AlmKeys.Azure | AlmKeys.GitHub | AlmKeys.GitLab | AlmKeys.BitbucketServer;
currentAlmTab: AlmTabs;
definitionKeyForDeletion?: string;
definitions: AlmSettingsBindingDefinitions;
- definitionStatus:
T.Dict<AlmSettingsBindingStatus>;
+ definitionStatus: Dict<AlmSettingsBindingStatus>;
loadingAlmDefinitions: boolean;
loadingProjectCount: boolean;
projectCount?: number;
AlmSettingsBindingDefinitions,
AlmSettingsBindingStatus
} from '../../../../types/alm-settings';
+import { Dict } from '../../../../types/types';
import { AlmTabs } from './AlmIntegration';
import AlmTab from './AlmTab';
import DeleteModal from './DeleteModal';
currentAlmTab: AlmTabs;
definitionKeyForDeletion?: string;
definitions: AlmSettingsBindingDefinitions;
- definitionStatus:
T.Dict<AlmSettingsBindingStatus>;
+ definitionStatus: Dict<AlmSettingsBindingStatus>;
loadingAlmDefinitions: boolean;
loadingProjectCount: boolean;
multipleAlmEnabled: boolean;
AlmBindingDefinitionBase,
AlmSettingsBindingStatus
} from '../../../../types/alm-settings';
+import { Dict } from '../../../../types/types';
import { AlmTabs } from './AlmIntegration';
import AlmTabRenderer from './AlmTabRenderer';
almTab: AlmTabs;
branchesEnabled: boolean;
definitions: AlmBindingDefinition[];
- definitionStatus:
T.Dict<AlmSettingsBindingStatus>;
+ definitionStatus: Dict<AlmSettingsBindingStatus>;
loadingAlmDefinitions: boolean;
loadingProjectCount: boolean;
multipleAlmEnabled: boolean;
AlmSettingsBindingStatus,
isBitbucketCloudBindingDefinition
} from '../../../../types/alm-settings';
+import { Dict } from '../../../../types/types';
import { ALM_INTEGRATION } from '../AdditionalCategoryKeys';
import CategoryDefinitionsList from '../CategoryDefinitionsList';
import AlmBindingDefinitionBox from './AlmBindingDefinitionBox';
export interface AlmTabRendererProps {
almTab: AlmTabs;
branchesEnabled: boolean;
- definitionStatus:
T.Dict<AlmSettingsBindingStatus>;
+ definitionStatus: Dict<AlmSettingsBindingStatus>;
editDefinition?: boolean;
editedDefinition?: AlmBindingDefinition;
definitions: AlmBindingDefinition[];
import { translate } from '../../../../helpers/l10n';
import { AlmKeys } from '../../../../types/alm-settings';
import { EditionKey } from '../../../../types/editions';
+import { AppState } from '../../../../types/types';
export interface CreationTooltipProps {
alm: AlmKeys;
- appState: T.AppState;
+ appState: AppState;
children: React.ReactElement<{}>;
preventCreation: boolean;
}
AlmSettingsInstance,
ProjectAlmBindingResponse
} from '../../../../types/alm-settings';
+import { Dict } from '../../../../types/types';
export interface AlmSpecificFormProps {
alm: AlmKeys;
instances: AlmSettingsInstance[];
- formData:
T.Omit<ProjectAlmBindingResponse, 'alm'>;
+ formData: Omit<ProjectAlmBindingResponse, 'alm'>;
onFieldChange: (id: keyof ProjectAlmBindingResponse, value: string | boolean) => void;
monorepoEnabled: boolean;
}
interface CommonFieldProps extends LabelProps {
help?: boolean;
- helpParams?: T.Dict<string | JSX.Element>;
+ helpParams?: Dict<string | JSX.Element>;
helpExample?: JSX.Element;
onFieldChange: (id: keyof ProjectAlmBindingResponse, value: string | boolean) => void;
propKey: keyof ProjectAlmBindingResponse;
} from '../../../../types/alm-settings';
import { EditionKey } from '../../../../types/editions';
import { Permissions } from '../../../../types/permissions';
+import { Component, CurrentUser } from '../../../../types/types';
import PRDecorationBindingRenderer from './PRDecorationBindingRenderer';
-type FormData =
T.Omit<ProjectAlmBindingResponse, 'alm'>;
+type FormData = Omit<ProjectAlmBindingResponse, 'alm'>;
interface StateProps {
monorepoEnabled: boolean;
}
interface Props {
- component: T.Component;
- currentUser: T.CurrentUser;
+ component: Component;
+ currentUser: CurrentUser;
}
interface State {
}
const REQUIRED_FIELDS_BY_ALM: {
- [almKey in AlmKeys]: Array<keyof T.Omit<FormData, 'key'>>;
+ [almKey in AlmKeys]: Array<keyof Omit<FormData, 'key'>>;
} = {
[AlmKeys.Azure]: ['repository', 'slug'],
[AlmKeys.BitbucketServer]: ['repository', 'slug'],
submitProjectAlmBinding(
alm: AlmKeys,
key: string,
- almSpecificFields?: T.Omit<FormData, 'key'>
+ almSpecificFields?: Omit<FormData, 'key'>
): Promise<void> {
const almSetting = key;
const project = this.props.component.key;
import AlmSpecificForm from './AlmSpecificForm';
export interface PRDecorationBindingRendererProps {
- formData:
T.Omit<ProjectAlmBindingResponse, 'alm'>;
+ formData: Omit<ProjectAlmBindingResponse, 'alm'>;
instances: AlmSettingsInstance[];
isChanged: boolean;
isConfigured: boolean;
import { keyBy, sortBy, uniqBy } from 'lodash';
import { ActionType } from '../../../store/utils/actions';
import { SettingCategoryDefinition } from '../../../types/settings';
+import { Dict } from '../../../types/types';
import { DEFAULT_CATEGORY, getCategoryName } from '../utils';
const enum Actions {
type Action = ActionType<typeof receiveDefinitions, Actions.ReceiveDefinitions>;
-export type State = T.Dict<SettingCategoryDefinition>;
+export type State = Dict<SettingCategoryDefinition>;
export function receiveDefinitions(definitions: SettingCategoryDefinition[]) {
return { type: Actions.ReceiveDefinitions, definitions };
import { omit } from 'lodash';
import { combineReducers } from 'redux';
import { ActionType } from '../../../store/utils/actions';
+import { Dict } from '../../../types/types';
const enum Actions {
CancelChange = 'settingsPage/CANCEL_CHANGE',
| ActionType<typeof stopLoading, Actions.StopLoading>;
export interface State {
- changedValues:
T.Dict<any>;
- loading: T.Dict<boolean>;
- validationMessages: T.Dict<string>;
+ changedValues: Dict<any>;
+ loading: Dict<boolean>;
+ validationMessages: Dict<string>;
}
export function cancelChange(key: string) {
import { Action as AppStateAction, Actions as AppStateActions } from '../../../store/appState';
import { ActionType } from '../../../store/utils/actions';
import { SettingValue } from '../../../types/settings';
+import { Dict } from '../../../types/types';
enum Actions {
receiveValues = 'RECEIVE_VALUES'
type Action = ActionType<typeof receiveValues, Actions.receiveValues>;
-type SettingsState = T.Dict<SettingValue>;
+type SettingsState = Dict<SettingValue>;
export interface State {
- components: T.Dict<SettingsState>;
+ components: Dict<SettingsState>;
global: SettingsState;
}
import { getGlobalSettingsUrl, getProjectSettingsUrl } from '../../helpers/urls';
import { AlmKeys } from '../../types/alm-settings';
import { Setting, SettingCategoryDefinition, SettingDefinition } from '../../types/settings';
+import { Component, Dict } from '../../types/types';
export const DEFAULT_CATEGORY = 'general';
}
if (item.type === 'PROPERTY_SET') {
- const value: T.Dict<string> = {};
+ const value: Dict<string> = {};
item.fields.forEach(field => (value[field.key] = getEmptyValue(field)));
return [value];
}
export function buildSettingLink(
definition: SettingCategoryDefinition,
- component?: T.Component
+ component?: Component
): LocationDescriptor {
const { category, key } = definition;
};
}
- const query: T.Dict<string> = {};
+ const query: Dict<string> = {};
if (key.startsWith('sonar.auth.gitlab')) {
query.alm = 'gitlab';
*/
import { mockClusterSysInfo, mockStandaloneSysInfo } from '../../../helpers/testMocks';
+import { SysInfoBase, SysInfoStandalone } from '../../../types/types';
import * as u from '../utils';
describe('parseQuery', () => {
})
)
).toBe('INFO');
- expect(u.getSystemLogsLevel({} as T.SysInfoStandalone)).toBe('INFO');
+ expect(u.getSystemLogsLevel({} as SysInfoStandalone)).toBe('INFO');
});
});
describe('getHealthCauses', () => {
it('should return the correct information', () => {
- expect(u.getHealthCauses({ 'Health Causes': ['Foo'] } as T.SysInfoBase)).toEqual(['Foo']);
+ expect(u.getHealthCauses({ 'Health Causes': ['Foo'] } as SysInfoBase)).toEqual(['Foo']);
});
});
describe('getHealth', () => {
it('should return the correct information', () => {
- expect(u.getHealth({ Health: 'GREEN' } as T.SysInfoBase)).toEqual('GREEN');
+ expect(u.getHealth({ Health: 'GREEN' } as SysInfoBase)).toEqual('GREEN');
});
});
import Suggestions from '../../../app/components/embed-docs-modal/Suggestions';
import UpdateNotification from '../../../app/components/update-notification/UpdateNotification';
import { translate } from '../../../helpers/l10n';
+import { SysInfoCluster, SysInfoStandalone } from '../../../types/types';
import '../styles.css';
import {
getClusterVersion,
interface State {
loading: boolean;
- sysInfoData?: T.SysInfoCluster | T.SysInfoStandalone;
+ sysInfoData?: SysInfoCluster | SysInfoStandalone;
}
export class App extends React.PureComponent<Props, State> {
import { sortBy } from 'lodash';
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { SysInfoAppNode, SysInfoCluster, SysInfoSearchNode } from '../../../types/types';
import {
getAppNodes,
getClusterMainCardSection,
interface Props {
expandedCards: string[];
- sysInfoData: T.SysInfoCluster;
+ sysInfoData: SysInfoCluster;
toggleCard: (toggledCard: string) => void;
}
<li className="note system-info-health-title">
{translate('system.application_nodes_title')}
</li>
- {sortBy(getAppNodes(sysInfoData), getNodeName).map((node: T.SysInfoAppNode) => (
+ {sortBy(getAppNodes(sysInfoData), getNodeName).map((node: SysInfoAppNode) => (
<HealthCard
health={getHealth(node)}
healthCauses={getHealthCauses(node)}
/>
))}
<li className="note system-info-health-title">{translate('system.search_nodes_title')}</li>
- {sortBy(getSearchNodes(sysInfoData), getNodeName).map((node: T.SysInfoSearchNode) => (
+ {sortBy(getSearchNodes(sysInfoData), getNodeName).map((node: SysInfoSearchNode) => (
<HealthCard
key={getNodeName(node)}
name={getNodeName(node)}
*/
import { map } from 'lodash';
import * as React from 'react';
+import { SysInfoStandalone } from '../../../types/types';
import {
getHealth,
getHealthCauses,
interface Props {
expandedCards: string[];
- sysInfoData: T.SysInfoStandalone;
+ sysInfoData: SysInfoStandalone;
toggleCard: (toggledCard: string) => void;
}
import BoxedGroupAccordion from '../../../../components/controls/BoxedGroupAccordion';
import { Alert } from '../../../../components/ui/Alert';
import { translate } from '../../../../helpers/l10n';
+import { HealthType, SysInfoValueObject } from '../../../../types/types';
import { getLogsLevel, groupSections, LOGS_LEVELS } from '../../utils';
import HealthItem from './HealthItem';
import Section from './Section';
interface Props {
biggerHealth?: boolean;
- health?: T.HealthType;
+ health?: HealthType;
healthCauses?: string[];
onClick: (toggledCard: string) => void;
open: boolean;
name: string;
- sysInfoData: T.SysInfoValueObject;
+ sysInfoData: SysInfoValueObject;
}
export default function HealthCard({
import classNames from 'classnames';
import * as React from 'react';
import { Alert } from '../../../../components/ui/Alert';
+import { HealthType } from '../../../../types/types';
interface Props {
className?: string;
- health: T.HealthType;
+ health: HealthType;
healthCause: string;
}
import StatusIndicator from '../../../../components/common/StatusIndicator';
import Tooltip from '../../../../components/controls/Tooltip';
import { translateWithParameters } from '../../../../helpers/l10n';
+import { HealthType } from '../../../../types/types';
import HealthCauseItem from './HealthCauseItem';
interface Props {
biggerHealth?: boolean;
name?: string;
className?: string;
- health: T.HealthType;
+ health: HealthType;
healthCauses?: string[];
}
*/
import { map } from 'lodash';
import * as React from 'react';
+import { SysInfoValueObject } from '../../../../types/types';
import SysInfoItem from './SysInfoItem';
interface Props {
name?: string;
- items: T.SysInfoValueObject;
+ items: SysInfoValueObject;
}
export default function Section({ name, items }: Props) {
import { map } from 'lodash';
import * as React from 'react';
import { translate } from '../../../../helpers/l10n';
+import { HealthType, SysInfoValue } from '../../../../types/types';
import { HEALTH_FIELD, STATE_FIELD } from '../../utils';
import HealthItem from './HealthItem';
export interface Props {
name: string;
- value: T.SysInfoValue;
+ value: SysInfoValue;
}
export default function SysInfoItem({ name, value }: Props) {
if (name === HEALTH_FIELD || name === STATE_FIELD) {
- return <HealthItem className="no-margin" health={value as T.HealthType} />;
+ return <HealthItem className="no-margin" health={value as HealthType} />;
}
if (value instanceof Array) {
return <code>{JSON.stringify(value)}</code>;
import { each, memoize, omit, omitBy, pickBy, sortBy } from 'lodash';
import { formatMeasure } from '../../helpers/measures';
import { cleanQuery, parseAsArray, parseAsString, serializeStringArray } from '../../helpers/query';
+import {
+ RawQuery,
+ SysInfoAppNode,
+ SysInfoBase,
+ SysInfoCluster,
+ SysInfoLogging,
+ SysInfoSearchNode,
+ SysInfoSection,
+ SysInfoStandalone,
+ SysInfoValueObject
+} from '../../types/types';
export interface Query {
expandedCards: string[];
export const WEB_LOGGING_FIELD = 'Web Logging';
export const WEB_PREFIX = 'Web';
-export function ignoreInfoFields(sysInfoObject: T.SysInfoValueObject) {
+export function ignoreInfoFields(sysInfoObject: SysInfoValueObject) {
return omit(sysInfoObject, [
ALMS_FIELD,
BUNDLED_FIELD,
]);
}
-export function getHealth(sysInfoObject: T.SysInfoBase) {
+export function getHealth(sysInfoObject: SysInfoBase) {
return sysInfoObject[HEALTH_FIELD];
}
-export function getHealthCauses(sysInfoObject: T.SysInfoBase) {
+export function getHealthCauses(sysInfoObject: SysInfoBase) {
return sysInfoObject[HEALTH_CAUSES_FIELD];
}
-export function getLogsLevel(sysInfoObject?: T.SysInfoValueObject): string {
+export function getLogsLevel(sysInfoObject?: SysInfoValueObject): string {
if (sysInfoObject !== undefined) {
if (isLogInfoBlock(sysInfoObject)) {
return sysInfoObject[LOGS_LEVEL_FIELD];
return DEFAULT_LOG_LEVEL;
}
-export function getAppNodes(sysInfoData: T.SysInfoCluster): T.SysInfoAppNode[] {
+export function getAppNodes(sysInfoData: SysInfoCluster): SysInfoAppNode[] {
return sysInfoData[APP_NODES_FIELD];
}
-export function getSearchNodes(sysInfoData: T.SysInfoCluster): T.SysInfoSearchNode[] {
+export function getSearchNodes(sysInfoData: SysInfoCluster): SysInfoSearchNode[] {
return sysInfoData[SEARCH_NODES_FIELD];
}
export function isCluster(
- sysInfoData: T.SysInfoCluster | T.SysInfoStandalone
-): sysInfoData is T.SysInfoCluster {
+ sysInfoData: SysInfoCluster | SysInfoStandalone
+): sysInfoData is SysInfoCluster {
return sysInfoData[SYSTEM_FIELD] && sysInfoData[SYSTEM_FIELD][HA_FIELD] === true;
}
-export function isLogInfoBlock(
- sysInfoObject: T.SysInfoValueObject
-): sysInfoObject is T.SysInfoLogging {
+export function isLogInfoBlock(sysInfoObject: SysInfoValueObject): sysInfoObject is SysInfoLogging {
return sysInfoObject[LOGS_LEVEL_FIELD] !== undefined;
}
export function hasLoggingInfo(
- sysInfoObject: T.SysInfoValueObject
-): sysInfoObject is T.SysInfoStandalone | T.SysInfoAppNode {
+ sysInfoObject: SysInfoValueObject
+): sysInfoObject is SysInfoStandalone | SysInfoAppNode {
return Boolean(sysInfoObject[WEB_LOGGING_FIELD] || sysInfoObject[CE_LOGGING_FIELD]);
}
-export function getServerId(sysInfoData: T.SysInfoCluster | T.SysInfoStandalone): string {
+export function getServerId(sysInfoData: SysInfoCluster | SysInfoStandalone): string {
return sysInfoData && sysInfoData[SYSTEM_FIELD][SERVER_ID_FIELD];
}
-export function getVersion(sysInfoData: T.SysInfoStandalone): string | undefined {
+export function getVersion(sysInfoData: SysInfoStandalone): string | undefined {
return sysInfoData && sysInfoData[SYSTEM_FIELD][VERSION_FIELD];
}
-export function getClusterVersion(sysInfoData: T.SysInfoCluster): string | undefined {
+export function getClusterVersion(sysInfoData: SysInfoCluster): string | undefined {
const appNodes = getAppNodes(sysInfoData);
return appNodes.length > 0 ? appNodes[0][SYSTEM_FIELD][VERSION_FIELD] : undefined;
}
-export function getSystemLogsLevel(sysInfoData: T.SysInfoCluster | T.SysInfoStandalone): string {
+export function getSystemLogsLevel(sysInfoData: SysInfoCluster | SysInfoStandalone): string {
if (isCluster(sysInfoData)) {
const logLevels = sortBy(getAppNodes(sysInfoData).map(getLogsLevel), logLevel =>
LOGS_LEVELS.indexOf(logLevel)
}
}
-export function getNodeName(nodeInfo: T.SysInfoAppNode | T.SysInfoSearchNode): string {
+export function getNodeName(nodeInfo: SysInfoAppNode | SysInfoSearchNode): string {
return nodeInfo[NAME_FIELD];
}
-function getSystemData(sysInfoData: T.SysInfoBase): T.SysInfoValueObject {
- const statData: T.SysInfoValueObject = {};
- const statistics = sysInfoData[STATS_FIELD] as T.SysInfoValueObject; // TODO
+function getSystemData(sysInfoData: SysInfoBase): SysInfoValueObject {
+ const statData: SysInfoValueObject = {};
+ const statistics = sysInfoData[STATS_FIELD] as SysInfoValueObject; // TODO
if (statistics) {
statData['Lines of Code'] = formatMeasure(statistics[NCLOC_FIELD] as number, 'INT');
}
return { ...sysInfoData[SYSTEM_FIELD], ...statData };
}
-export function getClusterMainCardSection(sysInfoData: T.SysInfoCluster): T.SysInfoValueObject {
+export function getClusterMainCardSection(sysInfoData: SysInfoCluster): SysInfoValueObject {
return {
...getSystemData(sysInfoData),
...omit(sysInfoData, [
};
}
-export function getStandaloneMainSections(sysInfoData: T.SysInfoBase): T.SysInfoValueObject {
+export function getStandaloneMainSections(sysInfoData: SysInfoBase): SysInfoValueObject {
return {
...getSystemData(sysInfoData),
...(omitBy(
key.startsWith(CE_FIELD_PREFIX) ||
key.startsWith(SEARCH_PREFIX) ||
key.startsWith(WEB_PREFIX)
- ) as T.SysInfoValueObject)
+ ) as SysInfoValueObject)
};
}
-export function getStandaloneSecondarySections(sysInfoData: T.SysInfoBase): T.SysInfoSection {
+export function getStandaloneSecondarySections(sysInfoData: SysInfoBase): SysInfoSection {
return {
- Web: pickBy(sysInfoData, (_, key) => key.startsWith(WEB_PREFIX)) as T.SysInfoValueObject,
+ Web: pickBy(sysInfoData, (_, key) => key.startsWith(WEB_PREFIX)) as SysInfoValueObject,
'Compute Engine': pickBy(sysInfoData, (_, key) =>
key.startsWith(CE_FIELD_PREFIX)
- ) as T.SysInfoValueObject,
+ ) as SysInfoValueObject,
'Search Engine': pickBy(sysInfoData, (_, key) =>
key.startsWith(SEARCH_PREFIX)
- ) as T.SysInfoValueObject
+ ) as SysInfoValueObject
};
}
);
}
-export function groupSections(sysInfoData: T.SysInfoValueObject) {
- const mainSection: T.SysInfoValueObject = {};
- const sections: T.SysInfoSection = {};
+export function groupSections(sysInfoData: SysInfoValueObject) {
+ const mainSection: SysInfoValueObject = {};
+ const sections: SysInfoSection = {};
each(sysInfoData, (item, key) => {
if (typeof item !== 'object' || item instanceof Array) {
mainSection[key] = item;
}
export const parseQuery = memoize(
- (urlQuery: T.RawQuery): Query => ({
+ (urlQuery: RawQuery): Query => ({
expandedCards: parseAsArray(urlQuery.expand, parseAsString)
})
);
export const serializeQuery = memoize(
- (query: Query): T.RawQuery =>
+ (query: Query): RawQuery =>
cleanQuery({
expand: serializeStringArray(query.expandedCards)
})
import handleRequiredAuthentication from '../../../helpers/handleRequiredAuthentication';
import { isLoggedIn } from '../../../helpers/users';
import { ProjectAlmBindingResponse } from '../../../types/alm-settings';
+import { Component, CurrentUser } from '../../../types/types';
export interface TutorialsAppProps {
- component: T.Component;
- currentUser: T.CurrentUser;
+ component: Component;
+ currentUser: CurrentUser;
projectBinding?: ProjectAlmBindingResponse;
}
import { withCurrentUser } from '../../components/hoc/withCurrentUser';
import { Location, Router, withRouter } from '../../components/hoc/withRouter';
import { translate } from '../../helpers/l10n';
+import { IdentityProvider, Paging, User } from '../../types/types';
import Header from './Header';
import Search from './Search';
import UsersList from './UsersList';
}
interface State {
- identityProviders: T.IdentityProvider[];
+ identityProviders: IdentityProvider[];
loading: boolean;
- paging?: T.Paging;
- users: T.User[];
+ paging?: Paging;
+ users: User[];
}
export class UsersApp extends React.PureComponent<Props, State> {
*/
import * as React from 'react';
import { translate } from '../../helpers/l10n';
+import { IdentityProvider, User } from '../../types/types';
import UserListItem from './components/UserListItem';
interface Props {
currentUser: { isLoggedIn: boolean; login?: string };
- identityProviders: T.IdentityProvider[];
+ identityProviders: IdentityProvider[];
onUpdateUsers: () => void;
updateTokensCount: (login: string, tokensCount: number) => void;
- users: T.User[];
+ users: User[];
}
export default function UsersList({
import { ResetButtonLink, SubmitButton } from '../../../components/controls/buttons';
import Modal from '../../../components/controls/Modal';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { UserActive } from '../../../types/types';
export interface Props {
onClose: () => void;
onUpdateUsers: () => void;
- user: T.UserActive;
+ user: UserActive;
}
interface State {
SelectListSearchParams
} from '../../../components/controls/SelectList';
import { translate } from '../../../helpers/l10n';
+import { User } from '../../../types/types';
interface Props {
onClose: () => void;
onUpdateUsers: () => void;
- user: T.User;
+ user: User;
}
interface State {
import MandatoryFieldsExplanation from '../../../components/ui/MandatoryFieldsExplanation';
import { translate } from '../../../helpers/l10n';
import { parseError } from '../../../helpers/request';
+import { User } from '../../../types/types';
interface Props {
isCurrentUser: boolean;
onClose: () => void;
- user: T.User;
+ user: User;
}
interface State {
import { SubmitButton } from '../../../components/controls/buttons';
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate } from '../../../helpers/l10n';
+import { UserToken } from '../../../types/types';
import TokensFormItem, { TokenDeleteConfirmation } from './TokensFormItem';
import TokensFormNewToken from './TokensFormNewToken';
loading: boolean;
newToken?: { name: string; token: string };
newTokenName: string;
- tokens: T.UserToken[];
+ tokens: UserToken[];
}
export default class TokensForm extends React.PureComponent<Props, State> {
}
};
- handleRevokeToken = (revokedToken: T.UserToken) => {
+ handleRevokeToken = (revokedToken: UserToken) => {
this.setState(
state => ({
tokens: state.tokens.filter(token => token.name !== revokedToken.name)
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate } from '../../../helpers/l10n';
import { limitComponentName } from '../../../helpers/path';
+import { UserToken } from '../../../types/types';
export type TokenDeleteConfirmation = 'inline' | 'modal';
interface Props {
deleteConfirmation: TokenDeleteConfirmation;
login: string;
- onRevokeToken: (token: T.UserToken) => void;
- token: T.UserToken;
+ onRevokeToken: (token: UserToken) => void;
+ token: UserToken;
}
interface State {
import { ResetButtonLink } from '../../../components/controls/buttons';
import Modal from '../../../components/controls/Modal';
import { translate } from '../../../helpers/l10n';
+import { User } from '../../../types/types';
import TokensForm from './TokensForm';
interface Props {
- user: T.User;
+ user: User;
onClose: () => void;
updateTokensCount: (login: string, tokensCount: number) => void;
}
} from '../../../components/controls/ActionsDropdown';
import { translate } from '../../../helpers/l10n';
import { isUserActive } from '../../../helpers/users';
+import { User } from '../../../types/types';
import DeactivateForm from './DeactivateForm';
import PasswordForm from './PasswordForm';
import UserForm from './UserForm';
interface Props {
isCurrentUser: boolean;
onUpdateUsers: () => void;
- user: T.User;
+ user: User;
}
interface State {
import MandatoryFieldsExplanation from '../../../components/ui/MandatoryFieldsExplanation';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { parseError } from '../../../helpers/request';
+import { User } from '../../../types/types';
import UserScmAccountInput from './UserScmAccountInput';
export interface Props {
onClose: () => void;
onUpdateUsers: () => void;
- user?: T.User;
+ user?: User;
}
interface State {
import { ButtonIcon } from '../../../components/controls/buttons';
import BulletListIcon from '../../../components/icons/BulletListIcon';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { User } from '../../../types/types';
import GroupsForm from './GroupsForm';
interface Props {
groups: string[];
onUpdateUsers: () => void;
- user: T.User;
+ user: User;
}
interface State {
import DateFromNow from '../../../components/intl/DateFromNow';
import Avatar from '../../../components/ui/Avatar';
import { translate } from '../../../helpers/l10n';
+import { IdentityProvider, User } from '../../../types/types';
import TokensFormModal from './TokensFormModal';
import UserActions from './UserActions';
import UserGroups from './UserGroups';
import UserScmAccounts from './UserScmAccounts';
interface Props {
- identityProvider?: T.IdentityProvider;
+ identityProvider?: IdentityProvider;
isCurrentUser: boolean;
onUpdateUsers: () => void;
updateTokensCount: (login: string, tokensCount: number) => void;
- user: T.User;
+ user: User;
}
interface State {
import { colors } from '../../../app/theme';
import { getTextColor } from '../../../helpers/colors';
import { getBaseUrl } from '../../../helpers/system';
+import { IdentityProvider, User } from '../../../types/types';
export interface Props {
- identityProvider?: T.IdentityProvider;
- user: T.User;
+ identityProvider?: IdentityProvider;
+ user: User;
}
export default function UserListItemIdentity({ identityProvider, user }: Props) {
import * as React from 'react';
import { revokeToken } from '../../../../api/user-tokens';
import { click, waitAndUpdate } from '../../../../helpers/testUtils';
+import { UserToken } from '../../../../types/types';
import TokensFormItem from '../TokensFormItem';
jest.mock('../../../../components/intl/DateFormatter');
revokeToken: jest.fn().mockResolvedValue(undefined)
}));
-const userToken: T.UserToken = {
+const userToken: UserToken = {
name: 'foo',
createdAt: '2019-01-15T15:06:33+0100',
lastConnectionDate: '2019-01-18T15:06:33+0100'
import { shallow } from 'enzyme';
import * as React from 'react';
import { click } from '../../../../helpers/testUtils';
+import { User } from '../../../../types/types';
import UserListItem from '../UserListItem';
jest.mock('../../../../components/intl/DateFromNow');
jest.mock('../../../../components/intl/DateTimeFormatter');
-const user: T.User = {
+const user: User = {
active: true,
lastConnectionDate: '2019-01-18T15:06:33+0100',
local: false,
*/
import { memoize } from 'lodash';
import { cleanQuery, parseAsString, serializeString } from '../../helpers/query';
+import { RawQuery } from '../../types/types';
export interface Query {
search: string;
}
export const parseQuery = memoize(
- (urlQuery: T.RawQuery): Query => ({
+ (urlQuery: RawQuery): Query => ({
search: parseAsString(urlQuery['search'])
})
);
export const serializeQuery = memoize(
- (query: Query): T.RawQuery =>
+ (query: Query): RawQuery =>
cleanQuery({
search: query.search ? serializeString(query.search) : undefined
})
import { Link } from 'react-router';
import LinkIcon from '../../../components/icons/LinkIcon';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { WebApi } from '../../../types/types';
import { getActionKey, serializeQuery } from '../utils';
import ActionChangelog from './ActionChangelog';
import DeprecatedBadge from './DeprecatedBadge';
import ResponseExample from './ResponseExample';
interface Props {
- action: T.WebApi.Action;
- domain: T.WebApi.Domain;
+ action: WebApi.Action;
+ domain: WebApi.Domain;
showDeprecated: boolean;
showInternal: boolean;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { WebApi } from '../../../types/types';
interface Props {
- changelog: T.WebApi.Changelog[];
+ changelog: WebApi.Changelog[];
}
export default function ActionChangelog({ changelog }: Props) {
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { WebApi } from '../../../types/types';
import { actionsFilter, getActionKey, Query } from '../utils';
import Action from './Action';
import DeprecatedBadge from './DeprecatedBadge';
import InternalBadge from './InternalBadge';
interface Props {
- domain: T.WebApi.Domain;
+ domain: WebApi.Domain;
query: Query;
}
import classNames from 'classnames';
import * as React from 'react';
import { Link } from 'react-router';
+import { WebApi } from '../../../types/types';
import { actionsFilter, isDomainPathActive, Query, serializeQuery } from '../utils';
import DeprecatedBadge from './DeprecatedBadge';
import InternalBadge from './InternalBadge';
interface Props {
- domains: T.WebApi.Domain[];
+ domains: WebApi.Domain[];
query: Query;
splat: string;
}
})
.filter(domain => domain.filteredActions.length);
- const renderDomain = (domain: T.WebApi.Domain) => {
+ const renderDomain = (domain: WebApi.Domain) => {
const internal = !domain.actions.find(action => !action.internal);
return (
<Link
*/
import * as React from 'react';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { WebApi } from '../../../types/types';
import DeprecatedBadge from './DeprecatedBadge';
import InternalBadge from './InternalBadge';
interface Props {
- params: T.WebApi.Param[];
+ params: WebApi.Param[];
showDeprecated: boolean;
showInternal: boolean;
}
export default class Params extends React.PureComponent<Props> {
- renderKey(param: T.WebApi.Param) {
+ renderKey(param: WebApi.Param) {
return (
<td className="markdown" style={{ width: 180 }}>
<code>{param.key}</code>
);
}
- renderConstraint(param: T.WebApi.Param, field: keyof T.WebApi.Param, label: string) {
+ renderConstraint(param: WebApi.Param, field: keyof WebApi.Param, label: string) {
const value = param[field];
if (value !== undefined) {
return (
*/
import * as React from 'react';
import { fetchResponseExample as fetchResponseExampleApi } from '../../../api/web-api';
+import { WebApi } from '../../../types/types';
interface Props {
- action: T.WebApi.Action;
- domain: T.WebApi.Domain;
+ action: WebApi.Action;
+ domain: WebApi.Domain;
}
interface State {
- responseExample?: T.WebApi.Example;
+ responseExample?: WebApi.Example;
}
export default class ResponseExample extends React.PureComponent<Props, State> {
import { translate } from '../../../helpers/l10n';
import { addSideBarClass, removeSideBarClass } from '../../../helpers/pages';
import { scrollToElement } from '../../../helpers/scrolling';
+import { WebApi } from '../../../types/types';
import '../styles/web-api.css';
import {
getActionKey,
type Props = WithRouterProps;
interface State {
- domains: T.WebApi.Domain[];
+ domains: WebApi.Domain[];
}
export class WebApiApp extends React.PureComponent<Props, State> {
);
}
- parseDomains(domains: any[]): T.WebApi.Domain[] {
+ parseDomains(domains: any[]): WebApi.Domain[] {
return domains.map(domain => {
const deprecated = getLatestDeprecatedAction(domain);
const internal = !domain.actions.find((action: any) => !action.internal);
export default withRouter(WebApiApp);
/** Checks if all actions are deprecated, and returns the latest deprecated one */
-function getLatestDeprecatedAction(domain: Pick<T.WebApi.Domain, 'actions'>) {
+function getLatestDeprecatedAction(domain: Pick<WebApi.Domain, 'actions'>) {
const noVersion = { major: 0, minor: 0 };
const allActionsDeprecated = domain.actions.every(
({ deprecatedSince }) => deprecatedSince !== undefined
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { WebApi } from '../../../../types/types';
import Menu from '../Menu';
-const ACTION: T.WebApi.Action = {
+const ACTION: WebApi.Action = {
key: 'foo',
changelog: [],
description: 'Foo Desc',
internal: false,
post: false
};
-const DOMAIN1: T.WebApi.Domain = {
+const DOMAIN1: WebApi.Domain = {
actions: [ACTION],
path: 'foo',
description: 'API Foo'
};
-const DOMAIN2: T.WebApi.Domain = {
+const DOMAIN2: WebApi.Domain = {
actions: [ACTION],
path: 'bar',
description: 'API Bar'
const SEARCH_BAR = { search: 'Bar', deprecated: false, internal: false };
it('should render deprecated domains', () => {
- const domain: T.WebApi.Domain = {
+ const domain: WebApi.Domain = {
...DOMAIN2,
deprecatedSince: '5.0',
actions: [{ ...ACTION, deprecatedSince: '5.0' }]
});
it('should not render deprecated domains', () => {
- const domain: T.WebApi.Domain = {
+ const domain: WebApi.Domain = {
...DOMAIN2,
deprecatedSince: '5.0',
actions: [{ ...ACTION, deprecatedSince: '5.0' }]
});
it('should render internal domains', () => {
- const domain: T.WebApi.Domain = {
+ const domain: WebApi.Domain = {
...DOMAIN2,
internal: true,
actions: [{ ...ACTION, internal: true }]
});
it('should not render internal domains', () => {
- const domain: T.WebApi.Domain = {
+ const domain: WebApi.Domain = {
...DOMAIN2,
internal: true,
actions: [{ ...ACTION, internal: true }]
});
it('should render only domains with an action matching the query', () => {
- const domain: T.WebApi.Domain = {
+ const domain: WebApi.Domain = {
...DOMAIN2,
actions: [{ ...ACTION, key: 'bar', description: 'Bar Desc' }]
};
});
it('should also render domains with an actions description matching the query', () => {
- const domain: T.WebApi.Domain = {
+ const domain: WebApi.Domain = {
...DOMAIN1,
path: 'baz',
description: 'API Baz',
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { WebApi } from '../../../../types/types';
import Params from '../Params';
-const DEFAULT_PARAM: T.WebApi.Param = {
+const DEFAULT_PARAM: WebApi.Param = {
key: 'foo',
description: 'Foo desc',
internal: false,
});
it('should render different value constraints', () => {
- const param: T.WebApi.Param = {
+ const param: WebApi.Param = {
...DEFAULT_PARAM,
defaultValue: 'def',
exampleValue: 'foo',
parseAsString,
serializeString
} from '../../helpers/query';
+import { RawQuery, WebApi } from '../../types/types';
export interface Query {
search: string;
internal: boolean;
}
-export function actionsFilter(query: Query, domain: T.WebApi.Domain, action: T.WebApi.Action) {
+export function actionsFilter(query: Query, domain: WebApi.Domain, action: WebApi.Action) {
const lowSearchQuery = query.search.toLowerCase();
return (
(query.internal || !action.internal) &&
};
export const parseQuery = memoize(
- (urlQuery: T.RawQuery): Query => ({
+ (urlQuery: RawQuery): Query => ({
search: parseAsString(urlQuery['query']),
deprecated: parseAsOptionalBoolean(urlQuery['deprecated']) || false,
internal: parseAsOptionalBoolean(urlQuery['internal']) || false
);
export const serializeQuery = memoize(
- (query: Partial<Query>): T.RawQuery =>
+ (query: Partial<Query>): RawQuery =>
cleanQuery({
query: query.search ? serializeString(query.search) : undefined,
deprecated: query.deprecated || undefined,
import { createWebhook, deleteWebhook, searchWebhooks, updateWebhook } from '../../../api/webhooks';
import Suggestions from '../../../app/components/embed-docs-modal/Suggestions';
import { translate } from '../../../helpers/l10n';
+import { LightComponent, Webhook } from '../../../types/types';
import PageActions from './PageActions';
import PageHeader from './PageHeader';
import WebhooksList from './WebhooksList';
interface Props {
- component?: T.LightComponent;
+ component?: LightComponent;
}
interface State {
loading: boolean;
- webhooks: T.Webhook[];
+ webhooks: Webhook[];
}
export default class App extends React.PureComponent<Props, State> {
import MandatoryFieldMarker from '../../../components/ui/MandatoryFieldMarker';
import MandatoryFieldsExplanation from '../../../components/ui/MandatoryFieldsExplanation';
import { translate } from '../../../helpers/l10n';
+import { Webhook } from '../../../types/types';
interface Props {
onClose: () => void;
onDone: (data: Values) => Promise<void>;
- webhook?: T.Webhook;
+ webhook?: Webhook;
}
interface Values {
import SimpleModal from '../../../components/controls/SimpleModal';
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Webhook } from '../../../types/types';
interface Props {
onClose: () => void;
onSubmit: () => Promise<void>;
- webhook: T.Webhook;
+ webhook: Webhook;
}
export default function DeleteWebhookForm({ onClose, onSubmit, webhook }: Props) {
import Modal from '../../../components/controls/Modal';
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Paging, Webhook, WebhookDelivery } from '../../../types/types';
import DeliveryAccordion from './DeliveryAccordion';
interface Props {
onClose: () => void;
- webhook: T.Webhook;
+ webhook: Webhook;
}
interface State {
- deliveries: T.WebhookDelivery[];
+ deliveries: WebhookDelivery[];
loading: boolean;
- paging?: T.Paging;
+ paging?: Paging;
}
const PAGE_SIZE = 10;
import AlertErrorIcon from '../../../components/icons/AlertErrorIcon';
import AlertSuccessIcon from '../../../components/icons/AlertSuccessIcon';
import DateTimeFormatter from '../../../components/intl/DateTimeFormatter';
+import { WebhookDelivery } from '../../../types/types';
import DeliveryItem from './DeliveryItem';
interface Props {
- delivery: T.WebhookDelivery;
+ delivery: WebhookDelivery;
}
interface State {
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { formatMeasure } from '../../../helpers/measures';
+import { WebhookDelivery } from '../../../types/types';
interface Props {
className?: string;
- delivery: T.WebhookDelivery;
+ delivery: WebhookDelivery;
loading: boolean;
payload: string | undefined;
}
import { ResetButtonLink } from '../../../components/controls/buttons';
import Modal from '../../../components/controls/Modal';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Webhook, WebhookDelivery } from '../../../types/types';
import DeliveryItem from './DeliveryItem';
interface Props {
- delivery: T.WebhookDelivery;
+ delivery: WebhookDelivery;
onClose: () => void;
- webhook: T.Webhook;
+ webhook: Webhook;
}
interface State {
ActionsDropdownItem
} from '../../../components/controls/ActionsDropdown';
import { translate } from '../../../helpers/l10n';
+import { Webhook } from '../../../types/types';
import CreateWebhookForm from './CreateWebhookForm';
import DeleteWebhookForm from './DeleteWebhookForm';
import DeliveriesForm from './DeliveriesForm';
interface Props {
onDelete: (webhook: string) => Promise<void>;
onUpdate: (data: { webhook: string; name: string; url: string }) => Promise<void>;
- webhook: T.Webhook;
+ webhook: Webhook;
}
interface State {
*/
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { Webhook } from '../../../types/types';
import WebhookActions from './WebhookActions';
import WebhookItemLatestDelivery from './WebhookItemLatestDelivery';
interface Props {
onDelete: (webhook: string) => Promise<void>;
onUpdate: (data: { webhook: string; name: string; url: string }) => Promise<void>;
- webhook: T.Webhook;
+ webhook: Webhook;
}
export default function WebhookItem({ onDelete, onUpdate, webhook }: Props) {
import BulletListIcon from '../../../components/icons/BulletListIcon';
import DateTimeFormatter from '../../../components/intl/DateTimeFormatter';
import { translate } from '../../../helpers/l10n';
+import { Webhook } from '../../../types/types';
import LatestDeliveryForm from './LatestDeliveryForm';
interface Props {
- webhook: T.Webhook;
+ webhook: Webhook;
}
interface State {
import { sortBy } from 'lodash';
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { Webhook } from '../../../types/types';
import WebhookItem from './WebhookItem';
interface Props {
onDelete: (webhook: string) => Promise<void>;
onUpdate: (data: { webhook: string; name: string; url: string }) => Promise<void>;
- webhooks: T.Webhook[];
+ webhooks: Webhook[];
}
export default class WebhooksList extends React.PureComponent<Props> {
import { getBranchLikeQuery, isSameBranchLike } from '../../helpers/branch-like';
import { translate } from '../../helpers/l10n';
import { BranchLike } from '../../types/branch-like';
+import {
+ Dict,
+ DuplicatedFile,
+ Duplication,
+ FlowLocation,
+ Issue,
+ LinearIssueLocation,
+ Measure,
+ SourceLine,
+ SourceViewerFile
+} from '../../types/types';
import { WorkspaceContext } from '../workspace/context';
import DuplicationPopup from './components/DuplicationPopup';
import {
aroundLine?: number;
branchLike: BranchLike | undefined;
component: string;
- componentMeasures?: T.Measure[];
+ componentMeasures?: Measure[];
displayAllIssues?: boolean;
displayIssueLocationsCount?: boolean;
displayIssueLocationsLink?: boolean;
highlightedLine?: number;
// `undefined` elements mean they are located in a different file,
// but kept to maintaint the location indexes
- highlightedLocations?: (T.FlowLocation | undefined)[];
+ highlightedLocations?: (FlowLocation | undefined)[];
highlightedLocationMessage?: { index: number; text: string | undefined };
loadComponent?: (
component: string,
branchLike: BranchLike | undefined
- ) => Promise<T.SourceViewerFile>;
+ ) => Promise<SourceViewerFile>;
loadIssues?: (
component: string,
from: number,
to: number,
branchLike: BranchLike | undefined
- ) => Promise<T.Issue[]>;
+ ) => Promise<Issue[]>;
loadSources?: (
component: string,
from: number,
to: number,
branchLike: BranchLike | undefined
- ) => Promise<T.SourceLine[]>;
- onLoaded?: (component: T.SourceViewerFile, sources: T.SourceLine[], issues: T.Issue[]) => void;
+ ) => Promise<SourceLine[]>;
+ onLoaded?: (component: SourceViewerFile, sources: SourceLine[], issues: Issue[]) => void;
onLocationSelect?: (index: number) => void;
- onIssueChange?: (issue: T.Issue) => void;
+ onIssueChange?: (issue: Issue) => void;
onIssueSelect?: (issueKey: string) => void;
onIssueUnselect?: () => void;
scroll?: (element: HTMLElement) => void;
}
interface State {
- component?: T.SourceViewerFile;
- duplicatedFiles?: T.Dict<T.DuplicatedFile>;
- duplications?: T.Duplication[];
+ component?: SourceViewerFile;
+ duplicatedFiles?: Dict<DuplicatedFile>;
+ duplications?: Duplication[];
duplicationsByLine: { [line: number]: number[] };
hasSourcesAfter: boolean;
highlightedSymbols: string[];
- issueLocationsByLine: { [line: number]: T.LinearIssueLocation[] };
+ issueLocationsByLine: { [line: number]: LinearIssueLocation[] };
issuePopup?: { issue: string; name: string };
- issues?: T.Issue[];
- issuesByLine: { [line: number]: T.Issue[] };
+ issues?: Issue[];
+ issuesByLine: { [line: number]: Issue[] };
loading: boolean;
loadingSourcesAfter: boolean;
loadingSourcesBefore: boolean;
openIssuesByLine: { [line: number]: boolean };
selectedIssue?: string;
sourceRemoved: boolean;
- sources?: T.SourceLine[];
+ sources?: SourceLine[];
symbolsByLine: { [line: number]: string[] };
}
return this.props.loadSources || defaultLoadSources;
}
- computeCoverageStatus(lines: T.SourceLine[]) {
+ computeCoverageStatus(lines: SourceLine[]) {
return lines.map(line => ({ ...line, coverageStatus: getCoverageStatus(line) }));
}
this.setState({ loading: true });
const to = (this.props.aroundLine || 0) + LINES;
- const loadIssues = (component: T.SourceViewerFile, sources: T.SourceLine[]) => {
+ const loadIssues = (component: SourceViewerFile, sources: SourceLine[]) => {
this.loadIssues(this.props.component, 1, to, this.props.branchLike).then(
issues => {
if (this.mounted) {
}
};
- const onFailLoadSources = (response: Response, component: T.SourceViewerFile) => {
+ const onFailLoadSources = (response: Response, component: SourceViewerFile) => {
// TODO handle other statuses
if (this.mounted) {
if (response.status === 403) {
}
};
- const onResolve = (component: T.SourceViewerFile) => {
+ const onResolve = (component: SourceViewerFile) => {
const sourcesRequest =
component.q === 'FIL' || component.q === 'UTS' ? this.loadSources() : Promise.resolve([]);
sourcesRequest.then(
);
}
- loadSources = (): Promise<T.SourceLine[]> => {
+ loadSources = (): Promise<SourceLine[]> => {
return new Promise((resolve, reject) => {
const onFailLoadSources = (response: Response) => {
// TODO handle other statuses
}
};
- handleOpenIssues = (line: T.SourceLine) => {
+ handleOpenIssues = (line: SourceLine) => {
this.setState(state => ({
openIssuesByLine: { ...state.openIssuesByLine, [line.line]: true }
}));
};
- handleCloseIssues = (line: T.SourceLine) => {
+ handleCloseIssues = (line: SourceLine) => {
this.setState(state => ({
openIssuesByLine: { ...state.openIssuesByLine, [line.line]: false }
}));
};
- handleIssueChange = (issue: T.Issue) => {
+ handleIssueChange = (issue: Issue) => {
this.setState(({ issues = [] }) => {
const newIssues = issues.map(candidate => (candidate.key === issue.key ? issue : candidate));
return { issues: newIssues, issuesByLine: issuesByLine(newIssues) };
);
};
- renderCode(sources: T.SourceLine[]) {
+ renderCode(sources: SourceLine[]) {
const hasSourcesBefore = sources.length > 0 && sources[0].line > 1;
return (
<SourceViewerCode
);
}
- renderHeader(branchLike: BranchLike | undefined, sourceViewerFile: T.SourceViewerFile) {
+ renderHeader(branchLike: BranchLike | undefined, sourceViewerFile: SourceViewerFile) {
return this.props.slimHeader ? (
<SourceViewerHeaderSlim branchLike={branchLike} sourceViewerFile={sourceViewerFile} />
) : (
function defaultLoadComponent(
component: string,
branchLike: BranchLike | undefined
-): Promise<T.SourceViewerFile> {
+): Promise<SourceViewerFile> {
return Promise.all([
getComponentForSourceViewer({ component, ...getBranchLikeQuery(branchLike) }),
getComponentData({ component, ...getBranchLikeQuery(branchLike) })
import { translate } from '../../helpers/l10n';
import { BranchLike } from '../../types/branch-like';
import { MetricKey } from '../../types/metrics';
+import {
+ Duplication,
+ FlowLocation,
+ Issue,
+ LinearIssueLocation,
+ SourceLine
+} from '../../types/types';
import Line from './components/Line';
import { getSecondaryIssueLocationsForLine } from './helpers/issueLocations';
import {
displayIssueLocationsCount?: boolean;
displayIssueLocationsLink?: boolean;
displayLocationMarkers?: boolean;
- duplications: T.Duplication[] | undefined;
+ duplications: Duplication[] | undefined;
duplicationsByLine: { [line: number]: number[] };
hasSourcesAfter: boolean;
hasSourcesBefore: boolean;
highlightedLocationMessage: { index: number; text: string | undefined } | undefined;
// `undefined` elements mean they are located in a different file,
// but kept to maintain the location indexes
- highlightedLocations: (T.FlowLocation | undefined)[] | undefined;
+ highlightedLocations: (FlowLocation | undefined)[] | undefined;
highlightedSymbols: string[];
- issueLocationsByLine: { [line: number]: T.LinearIssueLocation[] };
+ issueLocationsByLine: { [line: number]: LinearIssueLocation[] };
issuePopup: { issue: string; name: string } | undefined;
- issues: T.Issue[] | undefined;
- issuesByLine: { [line: number]: T.Issue[] };
- loadDuplications: (line: T.SourceLine) => void;
+ issues: Issue[] | undefined;
+ issuesByLine: { [line: number]: Issue[] };
+ loadDuplications: (line: SourceLine) => void;
loadingSourcesAfter: boolean;
loadingSourcesBefore: boolean;
loadSourcesAfter: () => void;
loadSourcesBefore: () => void;
- onIssueChange: (issue: T.Issue) => void;
+ onIssueChange: (issue: Issue) => void;
onIssuePopupToggle: (issue: string, popupName: string, open?: boolean) => void;
- onIssuesClose: (line: T.SourceLine) => void;
+ onIssuesClose: (line: SourceLine) => void;
onIssueSelect: (issueKey: string) => void;
- onIssuesOpen: (line: T.SourceLine) => void;
+ onIssuesOpen: (line: SourceLine) => void;
onIssueUnselect: () => void;
onLocationSelect: ((index: number) => void) | undefined;
onSymbolClick: (symbols: string[]) => void;
scroll?: (element: HTMLElement) => void;
metricKey?: string;
selectedIssue: string | undefined;
- sources: T.SourceLine[];
+ sources: SourceLine[];
symbolsByLine: { [line: number]: string[] };
}
}
}
- getDuplicationsForLine = (line: T.SourceLine): number[] => {
+ getDuplicationsForLine = (line: SourceLine): number[] => {
return this.props.duplicationsByLine[line.line] || EMPTY_ARRAY;
};
- getIssuesForLine = (line: T.SourceLine): T.Issue[] => {
+ getIssuesForLine = (line: SourceLine): Issue[] => {
return this.props.issuesByLine[line.line] || EMPTY_ARRAY;
};
- getIssueLocationsForLine = (line: T.SourceLine): T.LinearIssueLocation[] => {
+ getIssueLocationsForLine = (line: SourceLine): LinearIssueLocation[] => {
return this.props.issueLocationsByLine[line.line] || EMPTY_ARRAY;
};
displayDuplications,
displayIssues
}: {
- line: T.SourceLine;
+ line: SourceLine;
index: number;
displayCoverage: boolean;
displayDuplications: boolean;
*/
import * as React from 'react';
import { BranchLike } from '../../types/branch-like';
+import { SourceViewerFile } from '../../types/types';
interface SourceViewerContextShape {
branchLike?: BranchLike;
- file: T.SourceViewerFile;
+ file: SourceViewerFile;
}
export const SourceViewerContext = React.createContext<SourceViewerContextShape>({
branchLike: {} as BranchLike,
- file: {} as T.SourceViewerFile
+ file: {} as SourceViewerFile
});
} from '../../helpers/urls';
import { BranchLike } from '../../types/branch-like';
import { ComponentQualifier } from '../../types/component';
+import { IssueType, Measure, SourceViewerFile } from '../../types/types';
import { WorkspaceContextShape } from '../workspace/context';
import MeasuresOverlay from './components/MeasuresOverlay';
interface Props {
branchLike: BranchLike | undefined;
- componentMeasures?: T.Measure[];
+ componentMeasures?: Measure[];
openComponent: WorkspaceContextShape['openComponent'];
showMeasures?: boolean;
- sourceViewerFile: T.SourceViewerFile;
+ sourceViewerFile: SourceViewerFile;
}
interface State {
<>
<div className="source-viewer-header-measure-separator" />
- {ISSUE_TYPES.map((type: T.IssueType) => {
+ {ISSUE_TYPES.map((type: IssueType) => {
const params = {
...getBranchLikeQuery(branchLike),
files: sourceViewerFile.path,
import { getBranchLikeUrl, getComponentIssuesUrl, getPathUrlAsString } from '../../helpers/urls';
import { BranchLike } from '../../types/branch-like';
import { ComponentQualifier } from '../../types/component';
+import { SourceViewerFile } from '../../types/types';
import './SourceViewerHeaderSlim.css';
export interface Props {
linkToProject?: boolean;
loading?: boolean;
onExpand?: () => void;
- sourceViewerFile: T.SourceViewerFile;
+ sourceViewerFile: SourceViewerFile;
}
export default function SourceViewerHeaderSlim(props: Props) {
import { mockMainBranch } from '../../../helpers/mocks/branch-like';
import { mockSourceViewerFile } from '../../../helpers/testMocks';
import { MetricKey } from '../../../types/metrics';
+import { Measure } from '../../../types/types';
import SourceViewerHeader from '../SourceViewerHeader';
it('should render correctly for a regular file', () => {
});
it('should render correctly if issue details are passed', () => {
- const componentMeasures: T.Measure[] = [
+ const componentMeasures: Measure[] = [
{ metric: MetricKey.code_smells, value: '1' },
{ metric: MetricKey.file_complexity_distribution, value: '42' }, // unused, should be ignored
{ metric: MetricKey.security_hotspots, value: '2' },
import { collapsedDirFromPath, fileFromPath } from '../../../helpers/path';
import { getProjectUrl } from '../../../helpers/urls';
import { BranchLike } from '../../../types/branch-like';
+import { Dict, DuplicatedFile, DuplicationBlock, SourceViewerFile } from '../../../types/types';
import { WorkspaceContextShape } from '../../workspace/context';
interface Props {
- blocks: T.DuplicationBlock[];
+ blocks: DuplicationBlock[];
branchLike: BranchLike | undefined;
- duplicatedFiles?: T.Dict<T.DuplicatedFile>;
+ duplicatedFiles?: Dict<DuplicatedFile>;
inRemovedComponent: boolean;
openComponent: WorkspaceContextShape['openComponent'];
- sourceViewerFile: T.SourceViewerFile;
+ sourceViewerFile: SourceViewerFile;
}
export default class DuplicationPopup extends React.PureComponent<Props> {
}
};
- renderDuplication(file: T.DuplicatedFile, children: React.ReactNode, line?: number) {
+ renderDuplication(file: DuplicatedFile, children: React.ReactNode, line?: number) {
return this.shouldLink() ? (
<a
data-key={file.key}
import { times } from 'lodash';
import * as React from 'react';
import { BranchLike } from '../../../types/branch-like';
+import { Issue, LinearIssueLocation, SourceLine } from '../../../types/types';
import './Line.css';
import LineCode from './LineCode';
import LineCoverage from './LineCoverage';
highlighted: boolean;
highlightedLocationMessage: { index: number; text: string | undefined } | undefined;
highlightedSymbols: string[] | undefined;
- issueLocations: T.LinearIssueLocation[];
+ issueLocations: LinearIssueLocation[];
issuePopup: { issue: string; name: string } | undefined;
- issues: T.Issue[];
+ issues: Issue[];
last: boolean;
- line: T.SourceLine;
- loadDuplications: (line: T.SourceLine) => void;
- onIssueChange: (issue: T.Issue) => void;
+ line: SourceLine;
+ loadDuplications: (line: SourceLine) => void;
+ onIssueChange: (issue: Issue) => void;
onIssuePopupToggle: (issueKey: string, popupName: string, open?: boolean) => void;
- onIssuesClose: (line: T.SourceLine) => void;
+ onIssuesClose: (line: SourceLine) => void;
onIssueSelect: (issueKey: string) => void;
- onIssuesOpen: (line: T.SourceLine) => void;
+ onIssuesOpen: (line: SourceLine) => void;
onIssueUnselect: () => void;
onLocationSelect: ((x: number) => void) | undefined;
onSymbolClick: (symbols: string[]) => void;
openIssues: boolean;
- previousLine: T.SourceLine | undefined;
+ previousLine: SourceLine | undefined;
renderDuplicationPopup: (index: number, line: number) => React.ReactNode;
scroll?: (element: HTMLElement) => void;
scrollToUncoveredLine?: boolean;
- secondaryIssueLocations: T.LinearIssueLocation[];
+ secondaryIssueLocations: LinearIssueLocation[];
selectedIssue: string | undefined;
verticalBuffer?: number;
}
import classNames from 'classnames';
import * as React from 'react';
import { BranchLike } from '../../../types/branch-like';
+import { Issue, LinearIssueLocation, SourceLine } from '../../../types/types';
import LocationIndex from '../../common/LocationIndex';
import LocationMessage from '../../common/LocationMessage';
import {
displayLocationMarkers?: boolean;
highlightedLocationMessage: { index: number; text: string | undefined } | undefined;
highlightedSymbols: string[] | undefined;
- issueLocations: T.LinearIssueLocation[];
+ issueLocations: LinearIssueLocation[];
issuePopup: { issue: string; name: string } | undefined;
- issues: T.Issue[];
- line: T.SourceLine;
- onIssueChange: (issue: T.Issue) => void;
+ issues: Issue[];
+ line: SourceLine;
+ onIssueChange: (issue: Issue) => void;
onIssuePopupToggle: (issue: string, popupName: string, open?: boolean) => void;
onIssueSelect: (issueKey: string) => void;
onLocationSelect: ((index: number) => void) | undefined;
onSymbolClick: (symbols: Array<string>) => void;
padding?: number;
scroll?: (element: HTMLElement) => void;
- secondaryIssueLocations: T.LinearIssueLocation[];
+ secondaryIssueLocations: LinearIssueLocation[];
selectedIssue: string | undefined;
showIssues?: boolean;
}
import * as React from 'react';
import Tooltip from '../../../components/controls/Tooltip';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { SourceLine } from '../../../types/types';
export interface LineCoverageProps {
- line: T.SourceLine;
+ line: SourceLine;
scroll?: (element: HTMLElement) => void;
scrollToUncoveredLine?: boolean;
}
);
}
-function getStatusTooltip(line: T.SourceLine) {
+function getStatusTooltip(line: SourceLine) {
if (line.coverageStatus === 'uncovered') {
if (line.conditions) {
return translateWithParameters('source_viewer.tooltip.uncovered.conditions', line.conditions);
import Tooltip from '../../../components/controls/Tooltip';
import { PopupPlacement } from '../../../components/ui/popups';
import { translate } from '../../../helpers/l10n';
+import { SourceLine } from '../../../types/types';
export interface LineDuplicationBlockProps {
blocksLoaded: boolean;
duplicated: boolean;
index: number;
- line: T.SourceLine;
- onClick?: (line: T.SourceLine) => void;
+ line: SourceLine;
+ onClick?: (line: SourceLine) => void;
renderDuplicationPopup: (index: number, line: number) => React.ReactNode;
}
import IssueIcon from '../../../components/icons/IssueIcon';
import { sortByType } from '../../../helpers/issues';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Issue, SourceLine } from '../../../types/types';
export interface LineIssuesIndicatorProps {
- issues: T.Issue[];
+ issues: Issue[];
issuesOpen?: boolean;
- line: T.SourceLine;
+ line: SourceLine;
onClick: () => void;
}
*/
import * as React from 'react';
import { BranchLike } from '../../../types/branch-like';
+import { Issue as TypeIssue } from '../../../types/types';
import Issue from '../../issue/Issue';
interface Props {
displayIssueLocationsCount?: boolean;
displayIssueLocationsLink?: boolean;
issuePopup: { issue: string; name: string } | undefined;
- issues: T.Issue[];
- onIssueChange: (issue: T.Issue) => void;
+ issues: TypeIssue[];
+ onIssueChange: (issue: TypeIssue) => void;
onIssueClick: (issueKey: string) => void;
onIssuePopupToggle: (issue: string, popupName: string, open?: boolean) => void;
selectedIssue: string | undefined;
import * as React from 'react';
import Toggler from '../../../components/controls/Toggler';
import { translateWithParameters } from '../../../helpers/l10n';
+import { SourceLine } from '../../../types/types';
import LineOptionsPopup from './LineOptionsPopup';
export interface LineNumberProps {
displayOptions: boolean;
firstLineNumber: number;
- line: T.SourceLine;
+ line: SourceLine;
}
export function LineNumber({ displayOptions, firstLineNumber, line }: LineNumberProps) {
import { PopupPlacement } from '../../../components/ui/popups';
import { translate } from '../../../helpers/l10n';
import { getCodeUrl, getPathUrlAsString } from '../../../helpers/urls';
+import { SourceLine } from '../../../types/types';
import { ActionsDropdownItem } from '../../controls/ActionsDropdown';
import { SourceViewerContext } from '../SourceViewerContext';
export interface LineOptionsPopupProps {
firstLineNumber: number;
- line: T.SourceLine;
+ line: SourceLine;
}
export function LineOptionsPopup({ firstLineNumber, line }: LineOptionsPopupProps) {
import Dropdown from '../../../components/controls/Dropdown';
import { PopupPlacement } from '../../../components/ui/popups';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { SourceLine } from '../../../types/types';
import SCMPopup from './SCMPopup';
export interface LineSCMProps {
- line: T.SourceLine;
- previousLine: T.SourceLine | undefined;
+ line: SourceLine;
+ previousLine: SourceLine | undefined;
}
export function LineSCM({ line, previousLine }: LineSCMProps) {
}
}
-function isSCMChanged(s: T.SourceLine, p: T.SourceLine | undefined) {
+function isSCMChanged(s: SourceLine, p: SourceLine | undefined) {
let changed = true;
if (p != null && s.scmRevision != null && p.scmRevision != null) {
changed = s.scmRevision !== p.scmRevision || s.scmDate !== p.scmDate;
} from '../../../helpers/measures';
import { getBranchLikeUrl } from '../../../helpers/urls';
import { BranchLike } from '../../../types/branch-like';
+import { IssueType as IssueTypeEnum } from '../../../types/issues';
+import { FacetValue, IssueType, MeasureEnhanced, SourceViewerFile } from '../../../types/types';
import Measure from '../../measure/Measure';
import SeverityHelper from '../../shared/SeverityHelper';
import CoverageRating from '../../ui/CoverageRating';
interface Props {
branchLike: BranchLike | undefined;
onClose: () => void;
- sourceViewerFile: T.SourceViewerFile;
+ sourceViewerFile: SourceViewerFile;
}
interface Measures {
- [metricKey: string]: T.MeasureEnhanced;
+ [metricKey: string]: MeasureEnhanced;
}
interface State {
loading: boolean;
measures: Measures;
- severitiesFacet?: T.FacetValue[];
+ severitiesFacet?: FacetValue[];
showAllMeasures: boolean;
- tagsFacet?: T.FacetValue[];
- typesFacet?: T.FacetValue<T.IssueType>[];
+ tagsFacet?: FacetValue[];
+ typesFacet?: FacetValue<IssueType>[];
}
export default class MeasuresOverlay extends React.PureComponent<Props, State> {
return {
severitiesFacet: severitiesFacet && severitiesFacet.values,
tagsFacet: tagsFacet && tagsFacet.values,
- typesFacet: typesFacet && (typesFacet.values as T.FacetValue<T.IssueType>[])
+ typesFacet: typesFacet && (typesFacet.values as FacetValue<IssueType>[])
};
});
};
this.setState({ showAllMeasures: true });
};
- renderMeasure = (measure: T.MeasureEnhanced | undefined) => {
+ renderMeasure = (measure: MeasureEnhanced | undefined) => {
return measure ? <MeasuresOverlayMeasure key={measure.metric.key} measure={measure} /> : null;
};
);
};
- renderBigMeasure = (measure: T.MeasureEnhanced | undefined) => {
+ renderBigMeasure = (measure: MeasureEnhanced | undefined) => {
return measure ? (
<div className="measure measure-big" data-metric={measure.metric.key}>
<span className="measure-value">
<>
{typesFacet && (
<div className="measures">
- {sortBy(typesFacet, f => ISSUE_TYPES.indexOf(f.val)).map(f => (
+ {sortBy(typesFacet, f => ISSUE_TYPES.indexOf(f.val as IssueTypeEnum)).map(f => (
<div className="measure measure-one-line" key={f.val}>
<span className="measure-name">
<IssueTypeIcon className="little-spacer-right" query={f.val} />
);
};
- renderDomain = (domain: string, measures: T.MeasureEnhanced[]) => {
+ renderDomain = (domain: string, measures: MeasureEnhanced[]) => {
return (
<div className="measures-viewer-card" key={domain}>
<div className="measures">
import IssueTypeIcon from '../../../components/icons/IssueTypeIcon';
import { getLocalizedMetricName } from '../../../helpers/l10n';
import { isMetricKey, MetricKey } from '../../../types/metrics';
+import { Metric } from '../../../types/types';
import Measure from '../../measure/Measure';
export interface MeasureWithMetric {
- metric: T.Metric;
+ metric: Metric;
value?: string;
}
import classNames from 'classnames';
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { SourceLine } from '../../../types/types';
import DateFormatter from '../../intl/DateFormatter';
export interface SCMPopupProps {
- line: T.SourceLine;
+ line: SourceLine;
}
export function SCMPopup({ line }: SCMPopupProps) {
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { Issue } from '../../../../types/types';
import LineIssuesList from '../LineIssuesList';
-const issueBase: T.Issue = {
+const issueBase: Issue = {
actions: [],
component: '',
componentLongName: '',
};
it('render issues list', () => {
- const issues: T.Issue[] = [
+ const issues: Issue[] = [
{ ...issueBase, key: 'foo' },
{ ...issueBase, key: 'bar' }
];
import { mockBranch } from '../../../../helpers/mocks/branch-like';
import { click, waitAndUpdate } from '../../../../helpers/testUtils';
import { MetricKey } from '../../../../types/metrics';
+import { SourceViewerFile } from '../../../../types/types';
import MeasuresOverlay from '../MeasuresOverlay';
jest.mock('../../../../api/issues', () => ({
])
}));
-const sourceViewerFile: T.SourceViewerFile = {
+const sourceViewerFile: SourceViewerFile = {
key: 'component-key',
measures: {},
path: 'src/file.js',
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+
+import { Duplication, DuplicationBlock } from '../../../types/types';
+
// TODO Test this function, but I don't get the logic behind it
-export function filterDuplicationBlocksByLine(blocks: T.DuplicationBlock[], line: number) {
+export function filterDuplicationBlocksByLine(blocks: DuplicationBlock[], line: number) {
/* eslint-disable no-underscore-dangle */
let foundOne = false;
return blocks.filter(b => {
}
export function getDuplicationBlocksForIndex(
- duplications: T.Duplication[] | undefined,
+ duplications: Duplication[] | undefined,
index: number
) {
return (duplications && duplications[index] && duplications[index].blocks) || [];
}
-export function isDuplicationBlockInRemovedComponent(blocks: T.DuplicationBlock[]) {
+export function isDuplicationBlockInRemovedComponent(blocks: DuplicationBlock[]) {
return blocks.some(b => b._ref === undefined); // eslint-disable-line no-underscore-dangle
}
+import { SourceLine, SourceLineCoverageStatus } from '../../../types/types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-export default function getCoverageStatus(s: T.SourceLine): T.SourceLineCoverageStatus | undefined {
- let status: T.SourceLineCoverageStatus | undefined;
+export default function getCoverageStatus(s: SourceLine): SourceLineCoverageStatus | undefined {
+ let status: SourceLineCoverageStatus | undefined;
if (s.lineHits != null && s.lineHits > 0) {
status = 'partially-covered';
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { uniq } from 'lodash';
+import { LinearIssueLocation } from '../../../types/types';
export interface Token {
className: string;
*/
export function highlightIssueLocations(
tokens: Token[],
- issueLocations: T.LinearIssueLocation[],
+ issueLocations: LinearIssueLocation[],
rootClassName: string = ISSUE_LOCATION_CLASS
): Token[] {
issueLocations.forEach(location => {
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { flatten } from 'lodash';
+import { Duplication, Issue, LinearIssueLocation, SourceLine } from '../../../types/types';
import { splitByTokens } from './highlight';
import { getLinearLocations } from './issueLocations';
-export function issuesByLine(issues: T.Issue[]) {
- const index: { [line: number]: T.Issue[] } = {};
+export function issuesByLine(issues: Issue[]) {
+ const index: { [line: number]: Issue[] } = {};
issues.forEach(issue => {
const line = issue.textRange ? issue.textRange.endLine : 0;
if (!(line in index)) {
}
export function issuesByComponentAndLine(
- issues: T.Issue[] = []
-): { [component: string]: { [line: number]: T.Issue[] } } {
- return issues.reduce((mapping: { [component: string]: { [line: number]: T.Issue[] } }, issue) => {
+ issues: Issue[] = []
+): { [component: string]: { [line: number]: Issue[] } } {
+ return issues.reduce((mapping: { [component: string]: { [line: number]: Issue[] } }, issue) => {
mapping[issue.component] = mapping[issue.component] || {};
const line = issue.textRange ? issue.textRange.endLine : 0;
mapping[issue.component][line] = mapping[issue.component][line] || [];
}, {});
}
-export function locationsByLine(issues: Pick<T.Issue, 'textRange'>[]) {
- const index: { [line: number]: T.LinearIssueLocation[] } = {};
+export function locationsByLine(issues: Pick<Issue, 'textRange'>[]) {
+ const index: { [line: number]: LinearIssueLocation[] } = {};
issues.forEach(issue => {
getLinearLocations(issue.textRange).forEach(location => {
if (!(location.line in index)) {
return index;
}
-export function duplicationsByLine(duplications: T.Duplication[] | undefined) {
+export function duplicationsByLine(duplications: Duplication[] | undefined) {
if (duplications == null) {
return {};
}
return duplicationsByLine;
}
-export function symbolsByLine(sources: T.SourceLine[]) {
+export function symbolsByLine(sources: SourceLine[]) {
const index: { [line: number]: string[] } = {};
sources.forEach(line => {
const tokens = splitByTokens(line.code || '');
+import { FlowLocation, LinearIssueLocation, SourceLine, TextRange } from '../../../types/types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-export function getLinearLocations(textRange: T.TextRange | undefined): T.LinearIssueLocation[] {
+export function getLinearLocations(textRange: TextRange | undefined): LinearIssueLocation[] {
if (!textRange) {
return [];
}
}
export function getSecondaryIssueLocationsForLine(
- line: T.SourceLine,
- highlightedLocations: (T.FlowLocation | undefined)[] | undefined
-): T.LinearIssueLocation[] {
+ line: SourceLine,
+ highlightedLocations: (FlowLocation | undefined)[] | undefined
+): LinearIssueLocation[] {
if (!highlightedLocations) {
return [];
}
return highlightedLocations.reduce((locations, location) => {
- const linearLocations: T.LinearIssueLocation[] = location
+ const linearLocations: LinearIssueLocation[] = location
? getLinearLocations(location.textRange)
.filter(l => l.line === line.line)
.map(l => ({
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { intersection } from 'lodash';
+import { Issue, LinearIssueLocation } from '../../../types/types';
export function optimizeHighlightedSymbols(
symbolsForLine: string[] = [],
export function optimizeLocationMessage(
highlightedLocationMessage: { index: number; text: string | undefined } | undefined,
- optimizedSecondaryIssueLocations: T.LinearIssueLocation[]
+ optimizedSecondaryIssueLocations: LinearIssueLocation[]
) {
return highlightedLocationMessage != null &&
optimizedSecondaryIssueLocations.some(
: undefined;
}
-export function optimizeSelectedIssue(selectedIssue: string | undefined, issuesForLine: T.Issue[]) {
+export function optimizeSelectedIssue(selectedIssue: string | undefined, issuesForLine: Issue[]) {
return selectedIssue !== undefined && issuesForLine.find(issue => issue.key === selectedIssue)
? selectedIssue
: undefined;
import { getBranchLikeQuery } from '../../../helpers/branch-like';
import { parseIssueFromResponse } from '../../../helpers/issues';
import { BranchLike } from '../../../types/branch-like';
+import { Issue, RawQuery } from '../../../types/types';
// maximum possible value
const PAGE_SIZE = 500;
};
}
-export function loadPage(
- query: T.RawQuery,
- page: number,
- pageSize = PAGE_SIZE
-): Promise<T.Issue[]> {
+export function loadPage(query: RawQuery, page: number, pageSize = PAGE_SIZE): Promise<Issue[]> {
return searchIssues({
...query,
p: page,
}
export function loadPageAndNext(
- query: T.RawQuery,
+ query: RawQuery,
toLine: number,
page: number,
pageSize = PAGE_SIZE
-): Promise<T.Issue[]> {
+): Promise<Issue[]> {
return loadPage(query, page).then(issues => {
if (issues.length === 0) {
return [];
_fromLine: number,
toLine: number,
branchLike: BranchLike | undefined
-): Promise<T.Issue[]> {
+): Promise<Issue[]> {
const query = buildQuery(component, branchLike);
return new Promise(resolve => {
loadPageAndNext(query, toLine, 1).then(issues => {
import DropdownIcon from '../../components/icons/DropdownIcon';
import { getLocalizedMetricName, translate } from '../../helpers/l10n';
import { isDiffMetric } from '../../helpers/measures';
+import { Metric } from '../../types/types';
import AddGraphMetricPopup from './AddGraphMetricPopup';
interface Props {
addMetric: (metric: string) => void;
className?: string;
- metrics: T.Metric[];
+ metrics: Metric[];
metricsTypeFilter?: string[];
removeMetric: (metric: string) => void;
selectedMetrics: string[];
.map(metric => metric.key);
};
- getSelectedMetricsElements = (metrics: T.Metric[], selectedMetrics?: string[]) => {
+ getSelectedMetricsElements = (metrics: Metric[], selectedMetrics?: string[]) => {
const selected = selectedMetrics || this.props.selectedMetrics;
return metrics.filter(metric => selected.includes(metric.key)).map(metric => metric.key);
};
import AdvancedTimeline from '../../components/charts/AdvancedTimeline';
import { formatMeasure, getShortType } from '../../helpers/measures';
import { MeasureHistory, Serie } from '../../types/project-activity';
+import { AnalysisEvent } from '../../types/types';
import GraphsLegendCustom from './GraphsLegendCustom';
import GraphsLegendStatic from './GraphsLegendStatic';
import GraphsTooltips from './GraphsTooltips';
interface Props {
- events: T.AnalysisEvent[];
+ events: AnalysisEvent[];
graph: string;
graphEndDate?: Date;
graphStartDate?: Date;
import * as React from 'react';
import { translate } from '../../helpers/l10n';
import { GraphType } from '../../types/project-activity';
+import { Metric } from '../../types/types';
import SelectLegacy from '../controls/SelectLegacy';
import AddGraphMetric from './AddGraphMetric';
import './styles.css';
className?: string;
removeCustomMetric?: (metric: string) => void;
graph: GraphType;
- metrics: T.Metric[];
+ metrics: Metric[];
metricsTypeFilter?: string[];
selectedMetrics?: string[];
updateGraph: (graphType: string) => void;
import { translate } from '../../helpers/l10n';
import { getBaseUrl } from '../../helpers/system';
import { GraphType, MeasureHistory, Serie } from '../../types/project-activity';
+import { ParsedAnalysis } from '../../types/types';
import GraphHistory from './GraphHistory';
import './styles.css';
import { getSeriesMetricType, hasHistoryData, isCustomGraph } from './utils';
interface Props {
- analyses: T.ParsedAnalysis[];
+ analyses: ParsedAnalysis[];
graph: GraphType;
graphs: Serie[][];
graphEndDate?: Date;
import { Popup, PopupPlacement } from '../../components/ui/popups';
import { isDefined } from '../../helpers/types';
import { MeasureHistory, Serie } from '../../types/project-activity';
+import { AnalysisEvent } from '../../types/types';
import DateTimeFormatter from '../intl/DateTimeFormatter';
import GraphsTooltipsContent from './GraphsTooltipsContent';
import GraphsTooltipsContentCoverage from './GraphsTooltipsContentCoverage';
import { DEFAULT_GRAPH } from './utils';
interface Props {
- events: T.AnalysisEvent[];
+ events: AnalysisEvent[];
formatValue: (tick: number | string) => string;
graph: string;
graphWidth: number;
*/
import * as React from 'react';
import EventInner from '../../apps/projectActivity/components/EventInner';
+import { AnalysisEvent } from '../../types/types';
interface Props {
addSeparator: boolean;
- events: T.AnalysisEvent[];
+ events: AnalysisEvent[];
}
export default function GraphsTooltipsContentEvents({ addSeparator, events }: Props) {
import ChartLegendIcon from '../../components/icons/ChartLegendIcon';
import Rating from '../../components/ui/Rating';
import { MeasureHistory } from '../../types/project-activity';
+import { Dict } from '../../types/types';
export interface GraphsTooltipsContentIssuesProps {
index: number;
value: string;
}
-const METRIC_RATING: T.Dict<string> = {
+const METRIC_RATING: Dict<string> = {
bugs: 'reliability_rating',
vulnerabilities: 'security_rating',
code_smells: 'sqale_rating'
import { get, save } from '../../helpers/storage';
import { MetricKey } from '../../types/metrics';
import { GraphType, MeasureHistory, Serie } from '../../types/project-activity';
+import { Dict, Metric } from '../../types/types';
export const DEFAULT_GRAPH = GraphType.issues;
-const GRAPHS_METRICS_DISPLAYED: T.Dict<string[]> = {
+const GRAPHS_METRICS_DISPLAYED: Dict<string[]> = {
[GraphType.issues]: [MetricKey.bugs, MetricKey.code_smells, MetricKey.vulnerabilities],
[GraphType.coverage]: [MetricKey.lines_to_cover, MetricKey.uncovered_lines],
[GraphType.duplications]: [MetricKey.ncloc, MetricKey.duplicated_lines]
};
-const GRAPHS_METRICS: T.Dict<string[]> = {
+const GRAPHS_METRICS: Dict<string[]> = {
[GraphType.issues]: GRAPHS_METRICS_DISPLAYED[GraphType.issues].concat([
MetricKey.reliability_rating,
MetricKey.security_rating,
export function generateSeries(
measuresHistory: MeasureHistory[],
graph: GraphType,
- metrics: T.Metric[] | T.Dict<T.Metric>,
+ metrics: Metric[] | Dict<Metric>,
displayedMetrics: string[]
): Serie[] {
if (displayedMetrics.length <= 0 || measuresHistory === undefined) {
};
}
-function findMetric(key: string, metrics: T.Metric[] | T.Dict<T.Metric>) {
+function findMetric(key: string, metrics: Metric[] | Dict<Metric>) {
if (Array.isArray(metrics)) {
return metrics.find(metric => metric.key === key);
}
import * as React from 'react';
import { colors, rawSizes } from '../../app/theme';
import { isDefined } from '../../helpers/types';
+import { Chart } from '../../types/types';
import './AdvancedTimeline.css';
import './LineChart.css';
metricType: string;
padding: number[];
selectedDate?: Date;
- series: T.Chart.Serie[];
+ series: Chart.Serie[];
showAreas?: boolean;
startDate?: Date;
updateSelectedDate?: (selectedDate?: Date) => void;
.range([availableHeight, 0]);
};
- getYScale = (props: Props, availableHeight: number, flatData: T.Chart.Point[]): YScale => {
+ getYScale = (props: Props, availableHeight: number, flatData: Chart.Point[]): YScale => {
if (props.metricType === 'RATING') {
return this.getRatingScale(availableHeight);
} else if (props.metricType === 'LEVEL') {
.nice();
};
- getXScale = (
- { startDate, endDate }: Props,
- availableWidth: number,
- flatData: T.Chart.Point[]
- ) => {
+ getXScale = ({ startDate, endDate }: Props, availableWidth: number, flatData: Chart.Point[]) => {
const dateRange = extent(flatData, d => d.x) as [Date, Date];
const start = startDate && startDate > dateRange[0] ? startDate : dateRange[0];
const end = endDate && endDate < dateRange[1] ? endDate : dateRange[1];
if (state.mouseOver && firstSerie) {
const { updateTooltip } = this.props;
const date = state.xScale.invert(xPos);
- const bisectX = bisector<T.Chart.Point, Date>(d => d.x).right;
+ const bisectX = bisector<Chart.Point, Date>(d => d.x).right;
let idx = bisectX(firstSerie.data, date);
if (idx >= 0) {
const previousPoint = firstSerie.data[idx - 1];
};
renderLines = () => {
- const lineGenerator = d3Line<T.Chart.Point>()
+ const lineGenerator = d3Line<Chart.Point>()
.defined(d => Boolean(d.y || d.y === 0))
.x(d => this.state.xScale(d.x))
.y(d => this.state.yScale(d.y));
};
renderAreas = () => {
- const areaGenerator = area<T.Chart.Point>()
+ const areaGenerator = area<Chart.Point>()
.defined(d => Boolean(d.y || d.y === 0))
.x(d => this.state.xScale(d.x))
.y1(d => this.state.yScale(d.y))
import { formatMeasure } from '../../helpers/measures';
import { getLanguages, Store } from '../../store/rootReducer';
import { MetricType } from '../../types/metrics';
+import { Languages } from '../../types/types';
interface LanguageDistributionProps {
distribution: string;
- languages: T.Languages;
+ languages: Languages;
}
const NUMBER_FORMAT_THRESHOLD = 1000;
import * as React from 'react';
import { formatMeasure, localizeMetric } from '../../helpers/measures';
import { Location } from '../../helpers/urls';
+import { ComponentMeasureEnhanced } from '../../types/types';
import './TreeMap.css';
import TreeMapRect from './TreeMapRect';
metric?: { key: string; type: string };
size: number;
tooltip?: React.ReactNode;
- component: T.ComponentMeasureEnhanced;
+ component: ComponentMeasureEnhanced;
}
interface HierarchicalTreemapItem extends TreeMapItem {
interface Props {
height: number;
items: TreeMapItem[];
- onRectangleClick?: (item: T.ComponentMeasureEnhanced) => void;
+ onRectangleClick?: (item: ComponentMeasureEnhanced) => void;
width: number;
}
return prefix.substr(0, prefix.length - lastPrefixPart.length);
};
- handleClick = (component: T.ComponentMeasureEnhanced) => {
+ handleClick = (component: ComponentMeasureEnhanced) => {
if (this.props.onRectangleClick) {
this.props.onRectangleClick(component);
}
import * as React from 'react';
import Draggable, { DraggableBounds, DraggableCore, DraggableData } from 'react-draggable';
import { colors } from '../../app/theme';
+import { Chart } from '../../types/types';
import './LineChart.css';
import './ZoomTimeLine.css';
leakPeriodDate?: Date;
metricType: string;
padding: number[];
- series: T.Chart.Serie[];
+ series: Chart.Serie[];
showAreas?: boolean;
showXTicks: boolean;
startDate?: Date;
.range([availableHeight, 0]);
};
- getYScale = (availableHeight: number, flatData: T.Chart.Point[]): YScale => {
+ getYScale = (availableHeight: number, flatData: Chart.Point[]): YScale => {
if (this.props.metricType === 'RATING') {
return this.getRatingScale(availableHeight);
} else if (this.props.metricType === 'LEVEL') {
.nice();
};
- getXScale = (availableWidth: number, flatData: T.Chart.Point[]): XScale => {
+ getXScale = (availableWidth: number, flatData: Chart.Point[]): XScale => {
return scaleTime()
.domain(extent(flatData, d => d.x) as [Date, Date])
.range([0, availableWidth])
};
renderLines = (xScale: XScale, yScale: YScale) => {
- const lineGenerator = d3Line<T.Chart.Point>()
+ const lineGenerator = d3Line<Chart.Point>()
.defined(d => Boolean(d.y || d.y === 0))
.x(d => xScale(d.x))
.y(d => yScale(d.y));
};
renderAreas = (xScale: XScale, yScale: YScale) => {
- const areaGenerator = area<T.Chart.Point>()
+ const areaGenerator = area<Chart.Point>()
.defined(d => Boolean(d.y || d.y === 0))
.x(d => xScale(d.x))
.y1(d => yScale(d.y))
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { Chart } from '../../../types/types';
import AdvancedTimeline from '../AdvancedTimeline';
const newCodeLegendClass = '.new-code-legend';
);
}
-function mockData(i: number, date: string): T.Chart.Serie {
+function mockData(i: number, date: string): Chart.Serie {
return {
name: `t${i}`,
type: 'type',
import { mockHtmlElement } from '../../../helpers/mocks/dom';
import { mockEvent } from '../../../helpers/testMocks';
import { click } from '../../../helpers/testUtils';
+import { ComponentMeasureEnhanced } from '../../../types/types';
import BubbleChart from '../BubbleChart';
jest.mock('react-virtualized/dist/commonjs/AutoSizer', () => ({
});
});
-function shallowRender(props: Partial<BubbleChart<T.ComponentMeasureEnhanced>['props']> = {}) {
- return shallow<BubbleChart<T.ComponentMeasureEnhanced>>(
+function shallowRender(props: Partial<BubbleChart<ComponentMeasureEnhanced>['props']> = {}) {
+ return shallow<BubbleChart<ComponentMeasureEnhanced>>(
<BubbleChart
height={100}
items={[
import { translate } from '../../helpers/l10n';
import { sanitizeStringRestricted } from '../../helpers/sanitize';
import { TaskWarning } from '../../types/tasks';
+import { CurrentUser } from '../../types/types';
import { withCurrentUser } from '../hoc/withCurrentUser';
interface Props {
componentKey?: string;
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
onClose: () => void;
onWarningDismiss?: () => void;
taskId?: string;
import * as React from 'react';
import Tooltip from '../../components/controls/Tooltip';
import { translate } from '../../helpers/l10n';
+import { Visibility } from '../../types/types';
interface PrivacyBadgeContainerProps {
className?: string;
qualifier: string;
- visibility: T.Visibility;
+ visibility: Visibility;
}
export default function PrivacyBadgeContainer({
import MandatoryFieldMarker from '../../components/ui/MandatoryFieldMarker';
import MandatoryFieldsExplanation from '../../components/ui/MandatoryFieldsExplanation';
import { translate } from '../../helpers/l10n';
+import { LoggedInUser } from '../../types/types';
interface Props {
className?: string;
- user: T.LoggedInUser;
+ user: LoggedInUser;
onPasswordChange?: () => void;
}
import { Button } from '../../components/controls/buttons';
import ConfirmButton from '../../components/controls/ConfirmButton';
import { translate } from '../../helpers/l10n';
+import { SysStatus } from '../../types/types';
interface Props {
className?: string;
fetchSystemStatus: () => void;
- systemStatus: T.SysStatus;
+ systemStatus: SysStatus;
}
export default class RestartButton extends React.PureComponent<Props> {
import * as React from 'react';
import Radio from '../../components/controls/Radio';
import { translate } from '../../helpers/l10n';
+import { Visibility } from '../../types/types';
interface Props {
canTurnToPrivate?: boolean;
className?: string;
- onChange: (visibility: T.Visibility) => void;
+ onChange: (visibility: Visibility) => void;
showDetails?: boolean;
- visibility?: T.Visibility;
+ visibility?: Visibility;
}
export default class VisibilitySelector extends React.PureComponent<Props> {
import { Branch } from '../../types/branch-like';
import { ComponentQualifier } from '../../types/component';
import { ComponentReportStatus } from '../../types/component-report';
+import { AppState, Component, CurrentUser } from '../../types/types';
import { withCurrentUser } from '../hoc/withCurrentUser';
import ComponentReportActionsRenderer from './ComponentReportActionsRenderer';
interface Props {
- appState: Pick<T.AppState, 'qualifiers'>;
- component: T.Component;
+ appState: Pick<AppState, 'qualifiers'>;
+ component: Component;
branch?: Branch;
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
}
interface State {
import DropdownIcon from '../../components/icons/DropdownIcon';
import { translate, translateWithParameters } from '../../helpers/l10n';
import { Branch } from '../../types/branch-like';
+import { Component } from '../../types/types';
export interface ComponentReportActionsRendererProps {
- component: T.Component;
+ component: Component;
branch?: Branch;
frequency: string;
subscribed: boolean;
return null;
}
-type InputWrapperProps = T.Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value'> &
+type InputWrapperProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value'> &
WrappedComponentProps & {
innerRef: React.Ref<HTMLInputElement>;
value: Date | undefined;
import { isLoggedIn } from '../../helpers/users';
import { getCurrentUser, Store } from '../../store/rootReducer';
import { setHomePage } from '../../store/users';
+import { CurrentUser, HomePage } from '../../types/types';
interface StateProps {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
}
interface DispatchProps {
- setHomePage: (homepage: T.HomePage) => void;
+ setHomePage: (homepage: HomePage) => void;
}
interface Props extends StateProps, DispatchProps {
className?: string;
- currentPage: T.HomePage;
+ currentPage: HomePage;
}
-export const DEFAULT_HOMEPAGE: T.HomePage = { type: 'PROJECTS' };
+export const DEFAULT_HOMEPAGE: HomePage = { type: 'PROJECTS' };
export class HomePageSelect extends React.PureComponent<Props> {
handleClick = () => {
export default connect(mapStateToProps, mapDispatchToProps)(HomePageSelect);
-function isSameHomePage(a: T.HomePage, b: T.HomePage) {
+function isSameHomePage(a: HomePage, b: HomePage) {
return (
a.type === b.type &&
(a as any).branch === (b as any).branch &&
import { Formik, FormikActions, FormikProps } from 'formik';
import * as React from 'react';
-export type ChildrenProps<V> = T.Omit<FormikProps<V>, 'handleSubmit'>;
+export type ChildrenProps<V> = Omit<FormikProps<V>, 'handleSubmit'>;
interface Props<V> {
children: (props: ChildrenProps<V>) => React.ReactNode;
import { ButtonLink } from '../../../components/controls/buttons';
import { mockCurrentUser, mockLoggedInUser } from '../../../helpers/testMocks';
import { click, waitAndUpdate } from '../../../helpers/testUtils';
+import { HomePage } from '../../../types/types';
import { DEFAULT_HOMEPAGE, HomePageSelect } from '../HomePageSelect';
it('should render correctly', () => {
it('should correctly call webservices', async () => {
const setHomePage = jest.fn();
- const currentPage: T.HomePage = { type: 'MY_ISSUES' };
+ const currentPage: HomePage = { type: 'MY_ISSUES' };
const wrapper = shallowRender({ setHomePage, currentPage });
// Set homepage.
return <Button {...props} className={classNames('button-link', className)} />;
}
-export function SubmitButton(props: T.Omit<ButtonProps, 'type'>) {
+export function SubmitButton(props: Omit<ButtonProps, 'type'>) {
// do not prevent default to actually submit a form
return <Button {...props} preventDefault={false} type="submit" />;
}
-export function ResetButtonLink(props: T.Omit<ButtonProps, 'type'>) {
+export function ResetButtonLink(props: Omit<ButtonProps, 'type'>) {
return <ButtonLink {...props} type="reset" />;
}
import { Link } from 'react-router';
import DetachIcon from '../../components/icons/DetachIcon';
import { isSonarCloud } from '../../helpers/system';
+import { AppState } from '../../types/types';
import { withAppState } from '../hoc/withAppState';
interface OwnProps {
- appState: Pick<T.AppState, 'canAdmin'>;
+ appState: Pick<AppState, 'canAdmin'>;
customProps?: {
[k: string]: any;
};
import remarkCustomBlocks from 'remark-custom-blocks';
import remarkRehype from 'remark-rehype';
import { scrollToElement } from '../../helpers/scrolling';
+import { Dict } from '../../types/types';
import DocCollapsibleBlock from './DocCollapsibleBlock';
import DocImg from './DocImg';
import DocLink from './DocLink';
import DocTooltipLink from './DocTooltipLink';
interface Props {
- childProps?: T.Dict<string>;
+ childProps?: Dict<string>;
className?: string;
content: string;
isTooltip?: boolean;
}
function withChildProps<P>(
- WrappedComponent: React.ComponentType<P & { customProps?:
T.Dict<any> }>,
- childProps?:
T.Dict<any>
+ WrappedComponent: React.ComponentType<P & { customProps?: Dict<any> }>,
+ childProps?: Dict<any>
) {
return function withChildProps(props: P) {
return <WrappedComponent customProps={childProps} {...props} />;
import * as React from 'react';
import { Link } from 'react-router';
import DetachIcon from '../../components/icons/DetachIcon';
+import { Dict } from '../../types/types';
interface OwnProps {
- customProps?: T.Dict<string>;
+ customProps?: Dict<string>;
}
type Props = OwnProps & React.AnchorHTMLAttributes<HTMLAnchorElement>;
import { translate } from '../../helpers/l10n';
import { formatMeasure } from '../../helpers/measures';
import { queriesEqual } from '../../helpers/query';
+import { Dict, Paging, RawQuery } from '../../types/types';
import FacetBox from './FacetBox';
import FacetHeader from './FacetHeader';
import FacetItem from './FacetItem';
interface SearchResponse<S> {
maxResults?: boolean;
results: S[];
- paging?: T.Paging;
+ paging?: Paging;
}
export interface Props<S> {
getFacetItemText: (item: string) => string;
getSearchResultKey: (result: S) => string;
getSearchResultText: (result: S) => string;
- loadSearchResultCount?: (result: S[]) => Promise<T.Dict<number>>;
+ loadSearchResultCount?: (result: S[]) => Promise<Dict<number>>;
maxInitialItems: number;
maxItems: number;
minSearchLength: number;
- onChange: (changes: T.Dict<string | string[]>) => void;
+ onChange: (changes: Dict<string | string[]>) => void;
onClear?: () => void;
onItemClick?: (itemValue: string, multiple: boolean) => void;
onSearch: (query: string, page?: number) => Promise<SearchResponse<S>>;
onToggle: (property: string) => void;
open: boolean;
property: string;
- query?: T.RawQuery;
+ query?: RawQuery;
renderFacetItem: (item: string) => React.ReactNode;
renderSearchResult: (result: S, query: string) => React.ReactNode;
searchPlaceholder: string;
getSortedItems?: () => string[];
- stats: T.Dict<number> | undefined;
+ stats: Dict<number> | undefined;
values: string[];
}
query: string;
searching: boolean;
searchMaxResults?: boolean;
- searchPaging?: T.Paging;
+ searchPaging?: Paging;
searchResults?: S[];
- searchResultsCounts: T.Dict<number>;
+ searchResultsCounts: Dict<number>;
showFullList: boolean;
}
import { shallow } from 'enzyme';
import * as React from 'react';
import { mockStore } from '../../../helpers/testMocks';
+import { CurrentUser } from '../../../types/types';
import { withCurrentUser } from '../withCurrentUser';
-class X extends React.Component<{ currentUser: T.CurrentUser }> {
+class X extends React.Component<{ currentUser: CurrentUser }> {
render() {
return <div />;
}
import { KeyboardCodes } from '../../../helpers/keycodes';
import { mockComponent } from '../../../helpers/mocks/component';
import { KEYCODE_MAP, keydown } from '../../../helpers/testUtils';
+import { ComponentMeasure } from '../../../types/types';
import withKeyboardNavigation, { WithKeyboardNavigationProps } from '../withKeyboardNavigation';
class X extends React.Component<{
- components?: T.ComponentMeasure[];
- selected?: T.ComponentMeasure;
+ components?: ComponentMeasure[];
+ selected?: ComponentMeasure;
}> {
render() {
return <div />;
import * as React from 'react';
import handleRequiredAuthentication from '../../helpers/handleRequiredAuthentication';
import { isLoggedIn } from '../../helpers/users';
+import { CurrentUser } from '../../types/types';
import { getWrappedDisplayName } from './utils';
import { withCurrentUser } from './withCurrentUser';
export function whenLoggedIn<P>(WrappedComponent: React.ComponentType<P>) {
- class Wrapper extends React.Component<P & { currentUser: T.CurrentUser }> {
+ class Wrapper extends React.Component<P & { currentUser: CurrentUser }> {
static displayName = getWrappedDisplayName(WrappedComponent, 'whenLoggedIn');
componentDidMount() {
import * as React from 'react';
import { connect } from 'react-redux';
import { getAppState, Store } from '../../store/rootReducer';
+import { AppState } from '../../types/types';
import { getWrappedDisplayName } from './utils';
export function withAppState<P>(
- WrappedComponent: React.ComponentType<P & { appState: Partial<T.AppState> }>
+ WrappedComponent: React.ComponentType<P & { appState: Partial<AppState> }>
) {
- class Wrapper extends React.Component<P & { appState: T.AppState }> {
+ class Wrapper extends React.Component<P & { appState: AppState }> {
static displayName = getWrappedDisplayName(WrappedComponent, 'withAppState');
render() {
import * as React from 'react';
import { connect } from 'react-redux';
import { getCurrentUser, Store } from '../../store/rootReducer';
+import { CurrentUser } from '../../types/types';
import { getWrappedDisplayName } from './utils';
export function withCurrentUser<P>(
- WrappedComponent: React.ComponentType<P & { currentUser: T.CurrentUser }>
+ WrappedComponent: React.ComponentType<P & { currentUser: CurrentUser }>
) {
- class Wrapper extends React.Component<P & { currentUser: T.CurrentUser }> {
+ class Wrapper extends React.Component<P & { currentUser: CurrentUser }> {
static displayName = getWrappedDisplayName(WrappedComponent, 'withCurrentUser');
render() {
import * as React from 'react';
import PageActions from '../../components/ui/PageActions';
import { getComponentMeasureUniqueKey } from '../../helpers/component';
+import { ComponentMeasure } from '../../types/types';
import { getWrappedDisplayName } from './utils';
export interface WithKeyboardNavigationProps {
- components?: T.ComponentMeasure[];
+ components?: ComponentMeasure[];
cycle?: boolean;
isFile?: boolean;
onEndOfList?: () => void;
onGoToParent?: () => void;
- onHighlight?: (item: T.ComponentMeasure) => void;
- onSelect?: (item: T.ComponentMeasure) => void;
- selected?: T.ComponentMeasure;
+ onHighlight?: (item: ComponentMeasure) => void;
+ onSelect?: (item: ComponentMeasure) => void;
+ selected?: ComponentMeasure;
}
const KEY_SCOPE = 'key_nav';
const { selected } = this.props;
if (selected !== undefined) {
- this.props.onSelect(selected as T.ComponentMeasure);
+ this.props.onSelect(selected as ComponentMeasure);
}
};
import { uniqWith } from 'lodash';
import * as React from 'react';
import { addNotification, getNotifications, removeNotification } from '../../api/notifications';
+import { Notification } from '../../types/types';
import { getWrappedDisplayName } from './utils';
interface State {
channels: string[];
globalTypes: string[];
loading: boolean;
- notifications: T.Notification[];
+ notifications: Notification[];
perProjectTypes: string[];
}
export interface WithNotificationsProps {
- addNotification: (added: T.Notification) => void;
+ addNotification: (added: Notification) => void;
channels: string[];
globalTypes: string[];
loading: boolean;
- notifications: T.Notification[];
+ notifications: Notification[];
perProjectTypes: string[];
- removeNotification: (removed: T.Notification) => void;
+ removeNotification: (removed: Notification) => void;
}
export function withNotifications<P>(
);
};
- addNotificationToState = (added: T.Notification) => {
+ addNotificationToState = (added: Notification) => {
this.setState(state => {
const notifications = uniqWith([...state.notifications, added], this.areNotificationsEqual);
return { notifications };
});
};
- removeNotificationFromState = (removed: T.Notification) => {
+ removeNotificationFromState = (removed: Notification) => {
this.setState(state => {
const notifications = state.notifications.filter(
notification => !this.areNotificationsEqual(notification, removed)
});
};
- addNotification = (added: T.Notification) => {
+ addNotification = (added: Notification) => {
// optimistic update
this.addNotificationToState(added);
});
};
- removeNotification = (removed: T.Notification) => {
+ removeNotification = (removed: Notification) => {
// optimistic update
this.removeNotificationFromState(removed);
});
};
- areNotificationsEqual = (a: T.Notification, b: T.Notification) => {
+ areNotificationsEqual = (a: Notification, b: Notification) => {
return a.channel === b.channel && a.type === b.type && a.project === b.project;
};
export function withRouter<P extends InjectedProps>(
WrappedComponent: React.ComponentType<P & InjectedProps>
-): React.ComponentType<
T.Omit<P, keyof InjectedProps>> {
+): React.ComponentType<Omit<P, keyof InjectedProps>> {
return originalWithRouter(WrappedComponent as any);
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { IssueType } from '../../types/types';
import BugIcon from './BugIcon';
import CodeSmellIcon from './CodeSmellIcon';
import { IconProps } from './Icon';
import VulnerabilityIcon from './VulnerabilityIcon';
interface Props extends IconProps {
- type: T.IssueType;
+ type: IssueType;
}
export default function IssueIcon({ type, ...iconProps }: Props) {
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { IssueType } from '../../types/types';
import { IconProps } from './Icon';
import IssueIcon from './IssueIcon';
}
export default function IssueTypeIcon({ query, ...iconProps }: Props) {
- let type: T.IssueType;
+ let type: IssueType;
switch (query.toLowerCase()) {
case 'bug':
*/
import * as React from 'react';
import { colors } from '../../app/theme';
+import { Dict } from '../../types/types';
import Icon, { IconProps } from './Icon';
-const qualifierIcons: T.Dict<(props: IconProps) => React.ReactElement> = {
+const qualifierIcons: Dict<(props: IconProps) => React.ReactElement> = {
app: ApplicationIcon,
brc: SubProjectIcon,
dev: DeveloperIcon,
*/
import * as React from 'react';
import { colors } from '../../app/theme';
+import { Dict } from '../../types/types';
import Icon, { IconProps } from './Icon';
interface Props extends IconProps {
severity: string | null | undefined;
}
-const severityIcons: T.Dict<(props: IconProps) => React.ReactElement> = {
+const severityIcons: Dict<(props: IconProps) => React.ReactElement> = {
blocker: BlockerSeverityIcon,
critical: CriticalSeverityIcon,
major: MajorSeverityIcon,
*/
import * as React from 'react';
import { colors } from '../../app/theme';
+import { Dict } from '../../types/types';
import Icon, { IconProps } from './Icon';
interface Props extends IconProps {
status: string;
}
-const statusIcons: T.Dict<(props: IconProps) => React.ReactElement> = {
+const statusIcons: Dict<(props: IconProps) => React.ReactElement> = {
open: OpenStatusIcon,
confirmed: ConfirmedStatusIcon,
reopened: ReopenedStatusIcon,
*/
import * as React from 'react';
import { colors } from '../../app/theme';
+import { Dict } from '../../types/types';
import Icon, { IconProps } from './Icon';
interface Props extends IconProps {
status: string;
}
-const statusIcons: T.Dict<(props: IconProps) => React.ReactElement> = {
+const statusIcons: Dict<(props: IconProps) => React.ReactElement> = {
ok: OkTestStatusIcon,
failure: FailureTestStatusIcon,
error: ErrorTestStatusIcon,
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { IssueType } from '../../../types/types';
import IssueIcon from '../IssueIcon';
it('should render correctly', () => {
expect(shallowRender('SECURITY_HOTSPOT')).toMatchSnapshot();
});
-function shallowRender(type: T.IssueType) {
+function shallowRender(type: IssueType) {
return shallow(<IssueIcon type={type} />);
}
import * as React from 'react';
import { setIssueAssignee } from '../../api/issues';
import { BranchLike } from '../../types/branch-like';
+import { Issue as TypeIssue } from '../../types/types';
import { updateIssue } from './actions';
import './Issue.css';
import IssueView from './IssueView';
checked?: boolean;
displayLocationsCount?: boolean;
displayLocationsLink?: boolean;
- issue: T.Issue;
- onChange: (issue: T.Issue) => void;
+ issue: TypeIssue;
+ onChange: (issue: TypeIssue) => void;
onCheck?: (issue: string) => void;
onClick: (issueKey: string) => void;
- onFilter?: (property: string, issue: T.Issue) => void;
+ onFilter?: (property: string, issue: TypeIssue) => void;
onPopupToggle: (issue: string, popupName: string, open?: boolean) => void;
openPopup?: string;
selected: boolean;
import Checkbox from '../../components/controls/Checkbox';
import { translate } from '../../helpers/l10n';
import { BranchLike } from '../../types/branch-like';
+import { Issue } from '../../types/types';
import { updateIssue } from './actions';
import IssueActionsBar from './components/IssueActionsBar';
import IssueCommentLine from './components/IssueCommentLine';
currentPopup?: string;
displayLocationsCount?: boolean;
displayLocationsLink?: boolean;
- issue: T.Issue;
+ issue: Issue;
onAssign: (login: string) => void;
- onChange: (issue: T.Issue) => void;
+ onChange: (issue: Issue) => void;
onCheck?: (issue: string) => void;
onClick: (issueKey: string) => void;
- onFilter?: (property: string, issue: T.Issue) => void;
+ onFilter?: (property: string, issue: Issue) => void;
selected: boolean;
togglePopup: (popup: string, show: boolean | void) => void;
}
import throwGlobalError from '../../app/utils/throwGlobalError';
import { parseIssueFromResponse } from '../../helpers/issues';
import { IssueResponse } from '../../types/issues';
+import { Issue } from '../../types/types';
export const updateIssue = (
- onChange: (issue: T.Issue) => void,
+ onChange: (issue: Issue) => void,
resultPromise: Promise<IssueResponse>,
- oldIssue?: T.Issue,
- newIssue?: T.Issue
+ oldIssue?: Issue,
+ newIssue?: Issue
) => {
const optimisticUpdate = oldIssue !== undefined && newIssue !== undefined;
if (optimisticUpdate) {
import * as React from 'react';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { IssueResponse } from '../../../types/issues';
+import { Issue, RawQuery } from '../../../types/types';
import { updateIssue } from '../actions';
import IssueAssign from './IssueAssign';
import IssueCommentAction from './IssueCommentAction';
import IssueType from './IssueType';
interface Props {
- issue: T.Issue;
+ issue: Issue;
currentPopup?: string;
onAssign: (login: string) => void;
- onChange: (issue: T.Issue) => void;
+ onChange: (issue: Issue) => void;
togglePopup: (popup: string, show?: boolean) => void;
}
};
setIssueProperty = (
- property: keyof T.Issue,
+ property: keyof Issue,
popup: string,
- apiCall: (query: T.RawQuery) => Promise<IssueResponse>,
+ apiCall: (query: RawQuery) => Promise<IssueResponse>,
value: string
) => {
const { issue } = this.props;
this.props.togglePopup('comment', open);
};
- handleTransition = (issue: T.Issue) => {
+ handleTransition = (issue: Issue) => {
this.props.onChange(issue);
if (
issue.resolution === 'FALSE-POSITIVE' ||
import Toggler from '../../../components/controls/Toggler';
import DropdownIcon from '../../../components/icons/DropdownIcon';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Issue } from '../../../types/types';
import Avatar from '../../ui/Avatar';
import SetAssigneePopup from '../popups/SetAssigneePopup';
interface Props {
isOpen: boolean;
- issue: T.Issue;
+ issue: Issue;
canAssign: boolean;
onAssign: (login: string) => void;
togglePopup: (popup: string, show?: boolean) => void;
import { ButtonLink } from '../../../components/controls/buttons';
import Toggler from '../../../components/controls/Toggler';
import DropdownIcon from '../../../components/icons/DropdownIcon';
+import { Issue } from '../../../types/types';
import DateFromNow from '../../intl/DateFromNow';
import ChangelogPopup from '../popups/ChangelogPopup';
interface Props {
isOpen: boolean;
- issue: Pick<T.Issue, 'author' | 'creationDate' | 'key'>;
+ issue: Pick<Issue, 'author' | 'creationDate' | 'key'>;
creationDate: string;
togglePopup: (popup: string, show?: boolean) => void;
}
import * as React from 'react';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { formatMeasure } from '../../../helpers/measures';
+import { IssueChangelogDiff as TypeIssueChangelogDiff } from '../../../types/types';
interface Props {
- diff: T.IssueChangelogDiff;
+ diff: TypeIssueChangelogDiff;
}
export default function IssueChangelogDiff({ diff }: Props) {
import { ButtonLink } from '../../../components/controls/buttons';
import Toggler from '../../../components/controls/Toggler';
import { translate } from '../../../helpers/l10n';
+import { Issue } from '../../../types/types';
import { updateIssue } from '../actions';
import CommentPopup from '../popups/CommentPopup';
commentPlaceholder: string;
currentPopup?: string;
issueKey: string;
- onChange: (issue: T.Issue) => void;
+ onChange: (issue: Issue) => void;
toggleComment: (open?: boolean, placeholder?: string, autoTriggered?: boolean) => void;
}
import { PopupPlacement } from '../../../components/ui/popups';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { sanitizeString } from '../../../helpers/sanitize';
+import { IssueComment } from '../../../types/types';
import DateFromNow from '../../intl/DateFromNow';
import Avatar from '../../ui/Avatar';
import CommentDeletePopup from '../popups/CommentDeletePopup';
import CommentPopup from '../popups/CommentPopup';
interface Props {
- comment: T.IssueComment;
+ comment: IssueComment;
onDelete: (comment: string) => void;
onEdit: (comment: string, text: string) => void;
}
import DropdownIcon from '../../../components/icons/DropdownIcon';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { IssueResponse } from '../../../types/issues';
+import { Issue, RawQuery } from '../../../types/types';
import SeverityHelper from '../../shared/SeverityHelper';
import SetSeverityPopup from '../popups/SetSeverityPopup';
interface Props {
canSetSeverity: boolean;
isOpen: boolean;
- issue: Pick<T.Issue, 'severity'>;
+ issue: Pick<Issue, 'severity'>;
setIssueProperty: (
- property: keyof T.Issue,
+ property: keyof Issue,
popup: string,
- apiCall: (query: T.RawQuery) => Promise<IssueResponse>,
+ apiCall: (query: RawQuery) => Promise<IssueResponse>,
value: string
) => void;
togglePopup: (popup: string, show?: boolean) => void;
import { ButtonLink } from '../../../components/controls/buttons';
import Toggler from '../../../components/controls/Toggler';
import { translate } from '../../../helpers/l10n';
+import { Issue } from '../../../types/types';
import TagsList from '../../tags/TagsList';
import { updateIssue } from '../actions';
import SetIssueTagsPopup from '../popups/SetIssueTagsPopup';
interface Props {
canSetTags: boolean;
isOpen: boolean;
- issue: Pick<T.Issue, 'key' | 'tags'>;
- onChange: (issue: T.Issue) => void;
+ issue: Pick<Issue, 'key' | 'tags'>;
+ onChange: (issue: Issue) => void;
togglePopup: (popup: string, show?: boolean) => void;
}
updateIssue(
this.props.onChange,
setIssueTags({ issue: issue.key, tags: tags.join(',') }),
- issue as T.Issue,
- newIssue as T.Issue
+ issue as Issue,
+ newIssue as Issue
);
};
import { getComponentIssuesUrl } from '../../../helpers/urls';
import { BranchLike } from '../../../types/branch-like';
import { RuleStatus } from '../../../types/rules';
+import { Issue } from '../../../types/types';
import LocationIndex from '../../common/LocationIndex';
import { WorkspaceContext } from '../../workspace/context';
import IssueChangelog from './IssueChangelog';
currentPopup?: string;
displayLocationsCount?: boolean;
displayLocationsLink?: boolean;
- issue: T.Issue;
- onFilter?: (property: string, issue: T.Issue) => void;
+ issue: Issue;
+ onFilter?: (property: string, issue: Issue) => void;
togglePopup: (popup: string, show?: boolean) => void;
}
import Toggler from '../../../components/controls/Toggler';
import DropdownIcon from '../../../components/icons/DropdownIcon';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Issue } from '../../../types/types';
import StatusHelper from '../../shared/StatusHelper';
import { updateIssue } from '../actions';
import SetTransitionPopup from '../popups/SetTransitionPopup';
interface Props {
hasTransitions: boolean;
isOpen: boolean;
- issue: Pick<T.Issue, 'fromHotspot' | 'key' | 'resolution' | 'status' | 'transitions' | 'type'>;
- onChange: (issue: T.Issue) => void;
+ issue: Pick<Issue, 'fromHotspot' | 'key' | 'resolution' | 'status' | 'transitions' | 'type'>;
+ onChange: (issue: Issue) => void;
togglePopup: (popup: string, show?: boolean) => void;
}
import IssueTypeIcon from '../../../components/icons/IssueTypeIcon';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { IssueResponse } from '../../../types/issues';
+import { Issue, RawQuery } from '../../../types/types';
import SetTypePopup from '../popups/SetTypePopup';
interface Props {
canSetType: boolean;
isOpen: boolean;
- issue: Pick<T.Issue, 'type'>;
+ issue: Pick<Issue, 'type'>;
setIssueProperty: (
- property: keyof T.Issue,
+ property: keyof Issue,
popup: string,
- apiCall: (query: T.RawQuery) => Promise<IssueResponse>,
+ apiCall: (query: RawQuery) => Promise<IssueResponse>,
value: string
) => void;
togglePopup: (popup: string, show?: boolean) => void;
import DropdownIcon from '../../../components/icons/DropdownIcon';
import FilterIcon from '../../../components/icons/FilterIcon';
import { translate } from '../../../helpers/l10n';
+import { Issue } from '../../../types/types';
import SimilarIssuesPopup from '../popups/SimilarIssuesPopup';
interface Props {
isOpen: boolean;
- issue: T.Issue;
+ issue: Issue;
togglePopup: (popup: string, show?: boolean) => void;
- onFilter?: (property: string, issue: T.Issue) => void;
+ onFilter?: (property: string, issue: Issue) => void;
}
export default class SimilarIssuesFilter extends React.PureComponent<Props> {
- handleFilter = (property: string, issue: T.Issue) => {
+ handleFilter = (property: string, issue: Issue) => {
this.togglePopup(false);
if (this.props.onFilter) {
this.props.onFilter(property, issue);
import { shallow } from 'enzyme';
import * as React from 'react';
import { mockIssue } from '../../../../helpers/testMocks';
+import { Issue } from '../../../../types/types';
import IssueActionsBar from '../IssueActionsBar';
jest.mock('../../actions', () => ({ updateIssue: jest.fn() }));
});
describe('callback', () => {
- const issue: T.Issue = mockIssue();
+ const issue: Issue = mockIssue();
const onChangeMock = jest.fn();
const togglePopupMock = jest.fn();
*/
import { shallow } from 'enzyme';
import * as React from 'react';
+import { IssueChangelogDiff as TypeIssueChangelogDiff } from '../../../../types/types';
import IssueChangelogDiff from '../IssueChangelogDiff';
it('should render correctly', () => {
expect(shallowRender({ diff: { key: 'effort', oldValue: '10' } })).toMatchSnapshot();
});
-function shallowRender(props: Partial<{ diff: T.IssueChangelogDiff }> = {}) {
+function shallowRender(props: Partial<{ diff: TypeIssueChangelogDiff }> = {}) {
return shallow(<IssueChangelogDiff diff={{ key: 'foo' }} {...props} />);
}
import { shallow } from 'enzyme';
import * as React from 'react';
import { click } from '../../../../helpers/testUtils';
+import { IssueComment } from '../../../../types/types';
import IssueCommentLine from '../IssueCommentLine';
-const comment: T.IssueComment = {
+const comment: IssueComment = {
author: 'john.doe',
authorActive: true,
authorAvatar: 'gravatarhash',
import { shallow } from 'enzyme';
import * as React from 'react';
import { click } from '../../../../helpers/testUtils';
+import { Issue } from '../../../../types/types';
import IssueType from '../IssueType';
-const issue: Pick<T.Issue, 'type'> = { type: 'BUG' };
+const issue: Pick<Issue, 'type'> = { type: 'BUG' };
it('should render without the action when the correct rights are missing', () => {
expect(shallowRender({ canSetType: false })).toMatchSnapshot();
import { DropdownOverlay } from '../../../components/controls/Dropdown';
import { PopupPlacement } from '../../../components/ui/popups';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Issue, IssueChangelog } from '../../../types/types';
import DateTimeFormatter from '../../intl/DateTimeFormatter';
import Avatar from '../../ui/Avatar';
import IssueChangelogDiff from '../components/IssueChangelogDiff';
interface Props {
- issue: Pick<T.Issue, 'author' | 'creationDate' | 'key'>;
+ issue: Pick<Issue, 'author' | 'creationDate' | 'key'>;
}
interface State {
- changelog: T.IssueChangelog[];
+ changelog: IssueChangelog[];
}
export default class ChangelogPopup extends React.PureComponent<Props, State> {
import { PopupPlacement } from '../../../components/ui/popups';
import { KeyboardCodes } from '../../../helpers/keycodes';
import { translate } from '../../../helpers/l10n';
+import { IssueComment } from '../../../types/types';
import FormattingTips from '../../common/FormattingTips';
export interface CommentPopupProps {
- comment?: Pick<T.IssueComment, 'markdown'>;
+ comment?: Pick<IssueComment, 'markdown'>;
onComment: (text: string) => void;
toggleComment: (visible: boolean) => void;
placeholder: string;
import SearchBox from '../../../components/controls/SearchBox';
import { translate } from '../../../helpers/l10n';
import { isLoggedIn, isUserActive } from '../../../helpers/users';
+import { CurrentUser, UserActive, UserBase } from '../../../types/types';
import SelectList from '../../common/SelectList';
import SelectListItem from '../../common/SelectListItem';
import { withCurrentUser } from '../../hoc/withCurrentUser';
import Avatar from '../../ui/Avatar';
interface Props {
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
onSelect: (login: string) => void;
}
interface State {
currentUser: string;
query: string;
- users: T.UserActive[];
+ users: UserActive[];
}
const LIST_SIZE = 10;
export class SetAssigneePopup extends React.PureComponent<Props, State> {
- defaultUsersArray: T.UserActive[];
+ defaultUsersArray: UserActive[];
constructor(props: Props) {
super(props);
searchUsers({ q: query, ps: LIST_SIZE }).then(this.handleSearchResult, () => {});
};
- handleSearchResult = ({ users }: { users: T.UserBase[] }) => {
+ handleSearchResult = ({ users }: { users: UserBase[] }) => {
const activeUsers = users.filter(isUserActive);
this.setState({
users: activeUsers,
import { DropdownOverlay } from '../../../components/controls/Dropdown';
import SeverityIcon from '../../../components/icons/SeverityIcon';
import { translate } from '../../../helpers/l10n';
+import { Issue } from '../../../types/types';
import SelectList from '../../common/SelectList';
import SelectListItem from '../../common/SelectListItem';
type Props = {
- issue: Pick<T.Issue, 'severity'>;
+ issue: Pick<Issue, 'severity'>;
onSelect: (severity: string) => void;
};
import { FormattedMessage } from 'react-intl';
import { DropdownOverlay } from '../../../components/controls/Dropdown';
import { hasMessage, translate } from '../../../helpers/l10n';
+import { IssueType } from '../../../types/types';
import SelectList from '../../common/SelectList';
import SelectListItem from '../../common/SelectListItem';
fromHotspot: boolean;
onSelect: (transition: string) => void;
transitions: string[];
- type: T.IssueType;
+ type: IssueType;
}
export default function SetTransitionPopup({ fromHotspot, onSelect, transitions, type }: Props) {
import { DropdownOverlay } from '../../../components/controls/Dropdown';
import IssueTypeIcon from '../../../components/icons/IssueTypeIcon';
import { translate } from '../../../helpers/l10n';
+import { Issue, IssueType } from '../../../types/types';
import SelectList from '../../common/SelectList';
import SelectListItem from '../../common/SelectListItem';
interface Props {
- issue: Pick<T.Issue, 'type'>;
- onSelect: (type: T.IssueType) => void;
+ issue: Pick<Issue, 'type'>;
+ onSelect: (type: IssueType) => void;
}
const TYPES = ['BUG', 'VULNERABILITY', 'CODE_SMELL'];
import TagsIcon from '../../../components/icons/TagsIcon';
import { translate, translateWithParameters } from '../../../helpers/l10n';
import { fileFromPath, limitComponentName } from '../../../helpers/path';
+import { Issue } from '../../../types/types';
import SelectList from '../../common/SelectList';
import SelectListItem from '../../common/SelectListItem';
import SeverityHelper from '../../shared/SeverityHelper';
import Avatar from '../../ui/Avatar';
interface Props {
- issue: T.Issue;
- onFilter: (property: string, issue: T.Issue) => void;
+ issue: Issue;
+ onFilter: (property: string, issue: Issue) => void;
}
export default class SimilarIssuesPopup extends React.PureComponent<Props> {
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { getRatingTooltip as nextGetRatingTooltip, isDiffMetric } from '../../helpers/measures';
+import { Dict, Measure, MeasureEnhanced, MeasureIntern, Metric } from '../../types/types';
const KNOWN_RATINGS = [
'sqale_rating',
'security_review_rating'
];
-export function enhanceMeasure(measure: T.Measure, metrics: T.Dict<T.Metric>): T.MeasureEnhanced {
+export function enhanceMeasure(measure: Measure, metrics: Dict<Metric>): MeasureEnhanced {
return {
...measure,
metric: metrics[measure.metric],
};
}
-export function getLeakValue(measure: T.MeasureIntern | undefined): string | undefined {
+export function getLeakValue(measure: MeasureIntern | undefined): string | undefined {
return measure?.period?.value;
}
import { getBranchLikeQuery } from '../../helpers/branch-like';
import { getComponentDrilldownUrl, getComponentIssuesUrl } from '../../helpers/urls';
import { BranchLike } from '../../types/branch-like';
+import { Dict } from '../../types/types';
const ISSUE_MEASURES = [
'violations',
'new_vulnerabilities'
];
-const issueParamsPerMetric: T.Dict<T.Dict<string>> = {
+const issueParamsPerMetric: Dict<Dict<string>> = {
blocker_violations: { resolved: 'false', severities: 'BLOCKER' },
new_blocker_violations: { resolved: 'false', severities: 'BLOCKER' },
critical_violations: { resolved: 'false', severities: 'CRITICAL' },
};
propsToIssueParams = () => {
- const params: T.Dict<string | boolean> = {
+ const params: Dict<string | boolean> = {
...(issueParamsPerMetric[this.props.metric] || { resolved: 'false' })
};
import * as React from 'react';
import IssueTypeIcon from '../../components/icons/IssueTypeIcon';
import { translate } from '../../helpers/l10n';
+import { IssueType, RuleType } from '../../types/types';
interface Props {
className?: string;
- type: T.IssueType | T.RuleType;
+ type: IssueType | RuleType;
}
export default function TypeHelper(props: Props) {
import { getHostUrl } from '../../helpers/urls';
import { AlmSettingsInstance, ProjectAlmBindingResponse } from '../../types/alm-settings';
import { SettingsKey } from '../../types/settings';
+import { Component, LoggedInUser } from '../../types/types';
import { withRouter } from '../hoc/withRouter';
import TutorialSelectionRenderer from './TutorialSelectionRenderer';
import { TutorialModes } from './types';
interface Props extends Pick<WithRouterProps, 'router' | 'location'> {
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
projectBinding?: ProjectAlmBindingResponse;
willRefreshAutomatically?: boolean;
}
import { translate } from '../../helpers/l10n';
import { getBaseUrl } from '../../helpers/system';
import { AlmKeys, AlmSettingsInstance, ProjectAlmBindingResponse } from '../../types/alm-settings';
+import { Component, LoggedInUser } from '../../types/types';
import AzurePipelinesTutorial from './azure-pipelines/AzurePipelinesTutorial';
import BitbucketPipelinesTutorial from './bitbucket-pipelines/BitbucketPipelinesTutorial';
import GitHubActionTutorial from './github-action/GitHubActionTutorial';
export interface TutorialSelectionRendererProps {
almBinding?: AlmSettingsInstance;
baseUrl: string;
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
loading: boolean;
onSelectTutorial: (mode: TutorialModes) => void;
projectBinding?: ProjectAlmBindingResponse;
mockProjectBitbucketCloudBindingResponse,
mockProjectGithubBindingResponse
} from '../../../helpers/mocks/alm-settings';
+import { UserToken } from '../../../types/types';
import { buildBitbucketCloudLink, buildGithubLink, getUniqueTokenName } from '../utils';
describe('getUniqueTokenName', () => {
const initialTokenName = 'Analyze "lightsaber"';
it('should return the given name when the user has no token', () => {
- const userTokens: T.UserToken[] = [];
+ const userTokens: UserToken[] = [];
expect(getUniqueTokenName(userTokens, initialTokenName)).toBe(initialTokenName);
});
import { Button } from '../../../components/controls/buttons';
import { translate } from '../../../helpers/l10n';
import { AlmKeys } from '../../../types/alm-settings';
+import { Component, LoggedInUser } from '../../../types/types';
import AllSetStep from '../components/AllSetStep';
import FinishButton from '../components/FinishButton';
import Step from '../components/Step';
export interface AzurePipelinesTutorialProps {
alm?: AlmKeys;
baseUrl: string;
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
willRefreshAutomatically?: boolean;
}
import { connect } from 'react-redux';
import { translate } from '../../../helpers/l10n';
import { getLanguages, Store } from '../../../store/rootReducer';
+import { Component, Languages } from '../../../types/types';
import RenderOptions from '../components/RenderOptions';
import { BuildTools } from '../types';
import AnalysisCommand from './commands/AnalysisCommand';
export interface BranchesAnalysisStepProps {
- languages: T.Languages;
- component: T.Component;
+ languages: Languages;
+ component: Component;
onStepValidationChange: (isValid: boolean) => void;
}
import { Button } from '../../../components/controls/buttons';
import { ClipboardIconButton } from '../../../components/controls/clipboard';
import { translate } from '../../../helpers/l10n';
+import { Component, LoggedInUser } from '../../../types/types';
import EditTokenModal from '../components/EditTokenModal';
import SentenceWithHighlights from '../components/SentenceWithHighlights';
export interface ServiceEndpointStepProps {
baseUrl: string;
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
}
export default function ServiceEndpointStepContent(props: ServiceEndpointStepProps) {
import { ALM_DOCUMENTATION_PATHS } from '../../../../helpers/constants';
import { translate } from '../../../../helpers/l10n';
import { AlmKeys } from '../../../../types/alm-settings';
+import { AppState } from '../../../../types/types';
import { withAppState } from '../../../hoc/withAppState';
import SentenceWithHighlights from '../../components/SentenceWithHighlights';
export interface PublishStepsProps {
- appState: T.AppState;
+ appState: AppState;
}
export function PublishSteps(props: PublishStepsProps) {
const {
*/
import { Dictionary } from 'lodash';
import * as React from 'react';
+import { AppState, Component } from '../../../types/types';
import { withAppState } from '../../hoc/withAppState';
import { CompilationInfo } from '../components/CompilationInfo';
import CreateYmlFile from '../components/CreateYmlFile';
import { PreambuleYaml } from './PreambuleYaml';
export interface AnalysisCommandProps {
- appState: T.AppState;
+ appState: AppState;
buildTool: BuildTools;
- component: T.Component;
+ component: Component;
}
const YamlTemplate: Dictionary<(branchesEnabled?: boolean, projectKey?: string) => string> = {
AlmSettingsInstance,
ProjectAlmBindingResponse
} from '../../../types/alm-settings';
+import { Component, LoggedInUser } from '../../../types/types';
import AllSetStep from '../components/AllSetStep';
import FinishButton from '../components/FinishButton';
import GithubCFamilyExampleRepositories from '../components/GithubCFamilyExampleRepositories';
export interface BitbucketPipelinesTutorialProps {
almBinding?: AlmSettingsInstance;
baseUrl: string;
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
projectBinding?: ProjectAlmBindingResponse;
willRefreshAutomatically?: boolean;
}
import { FormattedMessage } from 'react-intl';
import { ClipboardIconButton } from '../../../components/controls/clipboard';
import { translate } from '../../../helpers/l10n';
+import { Component } from '../../../types/types';
import CodeSnippet from '../../common/CodeSnippet';
import DefaultProjectKey from '../components/DefaultProjectKey';
import { BuildTools } from '../types';
export interface PreambuleYamlProps {
buildTool: BuildTools;
- component: T.Component;
+ component: Component;
}
export function PreambuleYaml(props: PreambuleYamlProps) {
import { ClipboardIconButton } from '../../../components/controls/clipboard';
import { translate } from '../../../helpers/l10n';
import { AlmSettingsInstance, ProjectAlmBindingResponse } from '../../../types/alm-settings';
+import { Component, LoggedInUser } from '../../../types/types';
import SentenceWithHighlights from '../components/SentenceWithHighlights';
import TokenStepGenerator from '../components/TokenStepGenerator';
import { buildBitbucketCloudLink } from '../utils';
export interface RepositoryVariablesProps {
almBinding?: AlmSettingsInstance;
baseUrl: string;
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
onDone: () => void;
projectBinding?: ProjectAlmBindingResponse;
}
import { translate } from '../../../helpers/l10n';
import { getBaseUrl } from '../../../helpers/system';
import { AlmKeys } from '../../../types/alm-settings';
+import { AppState } from '../../../types/types';
import { withAppState } from '../../hoc/withAppState';
import SentenceWithHighlights from './SentenceWithHighlights';
export interface AllSetProps {
alm: AlmKeys;
- appState: T.AppState;
+ appState: AppState;
willRefreshAutomatically?: boolean;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { Component } from '../../../types/types';
import CodeSnippet from '../../common/CodeSnippet';
import SentenceWithFilename from './SentenceWithFilename';
export interface DefaultProjectKeyProps {
- component: T.Component;
+ component: Component;
}
const sonarProjectSnippet = (key: string) => `sonar.projectKey=${key}`;
import { Alert } from '../../../components/ui/Alert';
import DeferredSpinner from '../../../components/ui/DeferredSpinner';
import { translate, translateWithParameters } from '../../../helpers/l10n';
+import { Component, LoggedInUser } from '../../../types/types';
import { getUniqueTokenName } from '../utils';
interface State {
}
interface Props {
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
onClose: (token?: string) => void;
}
import * as React from 'react';
import { FormattedMessage } from 'react-intl';
import { translate } from '../../../helpers/l10n';
+import { Dict } from '../../../types/types';
export interface SentenceWithHighlightsProps {
highlightKeys: string[];
translationKey,
highlightPrefixKeys
}: SentenceWithHighlightsProps) {
- const values: T.Dict<JSX.Element> = {};
+ const values: Dict<JSX.Element> = {};
const transhighlightPrefixKeys = highlightPrefixKeys || translationKey;
highlightKeys.forEach(key => {
import { FormattedMessage } from 'react-intl';
import { Button } from '../../../components/controls/buttons';
import { translate } from '../../../helpers/l10n';
+import { Component, LoggedInUser } from '../../../types/types';
import EditTokenModal from './EditTokenModal';
export interface TokenStepGeneratorProps {
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
}
export default function TokenStepGenerator(props: TokenStepGeneratorProps) {
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { AppState, Component } from '../../../types/types';
import { withAppState } from '../../hoc/withAppState';
import { BuildTools } from '../types';
import CFamily from './commands/CFamily';
import Others from './commands/Others';
export interface AnalysisCommandProps {
- appState: T.AppState;
+ appState: AppState;
buildTool: BuildTools;
- component: T.Component;
+ component: Component;
onDone: () => void;
}
AlmSettingsInstance,
ProjectAlmBindingResponse
} from '../../../types/alm-settings';
+import { Component, LoggedInUser } from '../../../types/types';
import AllSetStep from '../components/AllSetStep';
import Step from '../components/Step';
import YamlFileStep from '../components/YamlFileStep';
export interface GitHubActionTutorialProps {
almBinding?: AlmSettingsInstance;
baseUrl: string;
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
projectBinding?: ProjectAlmBindingResponse;
willRefreshAutomatically?: boolean;
}
import { ClipboardIconButton } from '../../../components/controls/clipboard';
import { translate } from '../../../helpers/l10n';
import { AlmSettingsInstance, ProjectAlmBindingResponse } from '../../../types/alm-settings';
+import { Component, LoggedInUser } from '../../../types/types';
import SentenceWithHighlights from '../components/SentenceWithHighlights';
import TokenStepGenerator from '../components/TokenStepGenerator';
import { buildGithubLink } from '../utils';
export interface SecretStepProps {
almBinding?: AlmSettingsInstance;
baseUrl: string;
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
projectBinding?: ProjectAlmBindingResponse;
onDone: () => void;
}
*/
import * as React from 'react';
import { translate } from '../../../../helpers/l10n';
+import { Component } from '../../../../types/types';
import { CompilationInfo } from '../../components/CompilationInfo';
import CreateYmlFile from '../../components/CreateYmlFile';
import DefaultProjectKey from '../../components/DefaultProjectKey';
export interface CFamilyProps {
branchesEnabled?: boolean;
- component: T.Component;
+ component: Component;
onDone: () => void;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { Component } from '../../../../types/types';
import CreateYmlFile from '../../components/CreateYmlFile';
import FinishButton from '../../components/FinishButton';
export interface DotNetProps {
branchesEnabled?: boolean;
- component: T.Component;
+ component: Component;
onDone: () => void;
}
import { FormattedMessage } from 'react-intl';
import { ClipboardIconButton } from '../../../../components/controls/clipboard';
import { translate } from '../../../../helpers/l10n';
+import { Component } from '../../../../types/types';
import CodeSnippet from '../../../common/CodeSnippet';
import CreateYmlFile from '../../components/CreateYmlFile';
import FinishButton from '../../components/FinishButton';
export interface GradleProps {
branchesEnabled?: boolean;
- component: T.Component;
+ component: Component;
onDone: () => void;
}
const gradleYamlTemplate = (branchesEnabled: boolean) => `name: Build
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { Component } from '../../../../types/types';
import CreateYmlFile from '../../components/CreateYmlFile';
import FinishButton from '../../components/FinishButton';
export interface JavaMavenProps {
branchesEnabled?: boolean;
- component: T.Component;
+ component: Component;
onDone: () => void;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { Component } from '../../../../types/types';
import CreateYmlFile from '../../components/CreateYmlFile';
import DefaultProjectKey from '../../components/DefaultProjectKey';
import FinishButton from '../../components/FinishButton';
export interface OthersProps {
branchesEnabled?: boolean;
- component: T.Component;
+ component: Component;
onDone: () => void;
}
import { Button } from '../../../components/controls/buttons';
import { ClipboardIconButton } from '../../../components/controls/clipboard';
import { translate } from '../../../helpers/l10n';
+import { Component, LoggedInUser } from '../../../types/types';
import Step from '../components/Step';
import TokenStepGenerator from '../components/TokenStepGenerator';
export interface EnvironmentVariablesStepProps {
baseUrl: string;
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
finished: boolean;
onDone: () => void;
onOpen: () => void;
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
import { AlmKeys } from '../../../types/alm-settings';
+import { Component, LoggedInUser } from '../../../types/types';
import AllSetStep from '../components/AllSetStep';
import { BuildTools } from '../types';
import EnvironmentVariablesStep from './EnvironmentVariablesStep';
export interface GitLabCITutorialProps {
baseUrl: string;
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
willRefreshAutomatically?: boolean;
}
import { Button } from '../../../components/controls/buttons';
import { ClipboardIconButton } from '../../../components/controls/clipboard';
import { translate } from '../../../helpers/l10n';
+import { Component } from '../../../types/types';
import CodeSnippet from '../../common/CodeSnippet';
import { withCLanguageFeature } from '../../hoc/withCLanguageFeature';
import RenderOptions from '../components/RenderOptions';
export interface ProjectKeyStepProps {
buildTool?: BuildTools;
- component: T.Component;
+ component: Component;
finished: boolean;
hasCLanguageFeature: boolean;
onDone: () => void;
import { FormattedMessage } from 'react-intl';
import { ClipboardIconButton } from '../../../components/controls/clipboard';
import { translate } from '../../../helpers/l10n';
+import { AppState } from '../../../types/types';
import { withAppState } from '../../hoc/withAppState';
import FinishButton from '../components/FinishButton';
import GithubCFamilyExampleRepositories from '../components/GithubCFamilyExampleRepositories';
import PipeCommand from './commands/PipeCommand';
export interface YmlFileStepProps {
- appState: T.AppState;
+ appState: AppState;
buildTool?: BuildTools;
finished: boolean;
onDone: () => void;
AlmSettingsInstance,
ProjectAlmBindingResponse
} from '../../../types/alm-settings';
+import { Component, CurrentUserSetting } from '../../../types/types';
import AllSetStep from '../components/AllSetStep';
import JenkinsfileStep from './JenkinsfileStep';
import MultiBranchPipelineStep from './MultiBranchPipelineStep';
almBinding?: AlmSettingsInstance;
baseUrl: string;
branchesEnabled: boolean;
- component: T.Component;
+ component: Component;
projectBinding?: ProjectAlmBindingResponse;
- setCurrentUserSetting: (setting: T.CurrentUserSetting) => void;
+ setCurrentUserSetting: (setting: CurrentUserSetting) => void;
skipPreReqs: boolean;
willRefreshAutomatically?: boolean;
}
import * as React from 'react';
import { Alert } from '../../../components/ui/Alert';
import { translate } from '../../../helpers/l10n';
+import { Component } from '../../../types/types';
import { withCLanguageFeature } from '../../hoc/withCLanguageFeature';
import RenderOptions from '../components/RenderOptions';
import Step from '../components/Step';
export interface JenkinsfileStepProps {
baseUrl: string;
- component: T.Component;
+ component: Component;
hasCLanguageFeature: boolean;
finished: boolean;
onDone: () => void;
export interface LanguageProps {
onDone: () => void;
- component: T.Component;
+ component: Component;
baseUrl: string;
}
*/
import * as React from 'react';
import { translate } from '../../../../helpers/l10n';
+import { Component } from '../../../../types/types';
import FinishButton from '../../components/FinishButton';
import RenderOptions from '../../components/RenderOptions';
import { OSs } from '../../types';
import DotNetFramework from './DotNetFramework';
export interface DotNetCoreFrameworkProps {
- component: T.Component;
+ component: Component;
os: OSDotNet;
}
import { FormattedMessage } from 'react-intl';
import { Link } from 'react-router';
import { translate } from '../../../helpers/l10n';
+import { Component } from '../../../types/types';
export interface DoneNextStepsProps {
- component: T.Component;
+ component: Component;
}
export default function DoneNextSteps({ component }: DoneNextStepsProps) {
*/
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { Component, LoggedInUser } from '../../../types/types';
import InstanceMessage from '../../common/InstanceMessage';
import ProjectAnalysisStep from './ProjectAnalysisStep';
import TokenStep from './TokenStep';
}
interface Props {
- component: T.Component;
- currentUser: T.LoggedInUser;
+ component: Component;
+ currentUser: LoggedInUser;
}
interface State {
*/
import * as React from 'react';
import { translate } from '../../../helpers/l10n';
+import { Component } from '../../../types/types';
import Step from '../components/Step';
import { ManualTutorialConfig } from '../types';
import BuildToolForm from './BuildToolForm';
import AnalysisCommand from './commands/AnalysisCommand';
interface Props {
- component: T.Component;
+ component: Component;
onFinish?: (projectKey?: string) => void;
open: boolean;
stepNumber: number;
import Radio from '../../../components/controls/Radio';
import AlertSuccessIcon from '../../../components/icons/AlertSuccessIcon';
import { translate } from '../../../helpers/l10n';
+import { LoggedInUser, UserToken } from '../../../types/types';
import AlertErrorIcon from '../../icons/AlertErrorIcon';
import Step from '../components/Step';
import { getUniqueTokenName } from '../utils';
interface Props {
- currentUser: Pick<T.LoggedInUser, 'login'>;
+ currentUser: Pick<LoggedInUser, 'login'>;
finished: boolean;
initialTokenName?: string;
open: boolean;
selection: string;
tokenName?: string;
token?: string;
- tokens?: T.UserToken[];
+ tokens?: UserToken[];
}
export default class TokenStep extends React.PureComponent<Props, State> {
import { shallow } from 'enzyme';
import * as React from 'react';
import { change, click, submit, waitAndUpdate } from '../../../../helpers/testUtils';
+import { LoggedInUser } from '../../../../types/types';
import TokenStep from '../TokenStep';
jest.mock('../../../../api/user-tokens', () => ({
revokeToken: () => Promise.resolve()
}));
-const currentUser: Pick<T.LoggedInUser, 'login'> = { login: 'user' };
+const currentUser: Pick<LoggedInUser, 'login'> = { login: 'user' };
it('generates token', async () => {
const wrapper = shallow(
*/
import * as React from 'react';
import { getHostUrl } from '../../../../helpers/urls';
+import { Component } from '../../../../types/types';
import { BuildTools, ManualTutorialConfig } from '../../types';
import ClangGCCCustom from './ClangGCCCommand';
import DotNet from './DotNet';
import Other from './Other';
export interface AnalysisCommandProps {
- component: T.Component;
+ component: Component;
languageConfig: ManualTutorialConfig;
token?: string;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { Component } from '../../../../types/types';
import { CompilationInfo } from '../../components/CompilationInfo';
import { OSs } from '../../types';
import DownloadBuildWrapper from './DownloadBuildWrapper';
import ExecScanner from './ExecScanner';
export interface ClangGCCCustomProps {
- component: T.Component;
+ component: Component;
host: string;
os: OSs;
token: string;
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { Component } from '../../../../types/types';
import RenderOptions from '../../components/RenderOptions';
import DotNetCore from './DotNetCore';
import DotNetFramework from './DotNetFramework';
export interface DotNetProps {
- component: T.Component;
+ component: Component;
host: string;
token: string;
}
import { FormattedMessage } from 'react-intl';
import { Link } from 'react-router';
import { translate } from '../../../../helpers/l10n';
+import { Component } from '../../../../types/types';
import CodeSnippet from '../../../common/CodeSnippet';
import InstanceMessage from '../../../common/InstanceMessage';
import DoneNextSteps from '../DoneNextSteps';
export interface DotNetExecuteProps {
commands: string[];
- component: T.Component;
+ component: Component;
}
export default function DotNetExecute({ commands, component }: DotNetExecuteProps) {
import { FormattedMessage } from 'react-intl';
import { Link } from 'react-router';
import { translate } from '../../../../helpers/l10n';
+import { Component } from '../../../../types/types';
import CodeSnippet from '../../../common/CodeSnippet';
import InstanceMessage from '../../../common/InstanceMessage';
import { OSs } from '../../types';
import DoneNextSteps from '../DoneNextSteps';
export interface ExecScannerProps {
- component: T.Component;
+ component: Component;
host: string;
os: OSs;
token: string;
import { FormattedMessage } from 'react-intl';
import { Link } from 'react-router';
import { translate } from '../../../../helpers/l10n';
+import { Component } from '../../../../types/types';
import CodeSnippet from '../../../common/CodeSnippet';
import InstanceMessage from '../../../common/InstanceMessage';
import DoneNextSteps from '../DoneNextSteps';
export interface JavaGradleProps {
- component: T.Component;
+ component: Component;
host: string;
token: string;
}
import { FormattedMessage } from 'react-intl';
import { Link } from 'react-router';
import { translate } from '../../../../helpers/l10n';
+import { Component } from '../../../../types/types';
import CodeSnippet from '../../../common/CodeSnippet';
import InstanceMessage from '../../../common/InstanceMessage';
import DoneNextSteps from '../DoneNextSteps';
export interface JavaMavenProps {
- component: T.Component;
+ component: Component;
host: string;
token: string;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import * as React from 'react';
+import { Component } from '../../../../types/types';
import { OSs } from '../../types';
import DownloadScanner from './DownloadScanner';
import ExecScanner from './ExecScanner';
export interface OtherProps {
- component: T.Component;
+ component: Component;
host: string;
os: OSs;
token: string;
*/
import { convertGithubApiUrlToLink, stripTrailingSlash } from '../../helpers/urls';
import { AlmSettingsInstance, ProjectAlmBindingResponse } from '../../types/alm-settings';
+import { UserToken } from '../../types/types';
export function quote(os: string): (s: string) => string {
return os === 'win' ? (s: string) => `"${s}"` : (s: string) => s;
}`;
}
-export function getUniqueTokenName(tokens: T.UserToken[], initialTokenName = '') {
+export function getUniqueTokenName(tokens: UserToken[], initialTokenName = '') {
const hasToken = (name: string) => tokens.find(token => token.name === name) !== undefined;
if (!hasToken(initialTokenName)) {
import * as React from 'react';
import { colors, sizes } from '../../app/theme';
import { translate } from '../../helpers/l10n';
+import { Dict } from '../../types/types';
import AlertErrorIcon from '../icons/AlertErrorIcon';
import AlertSuccessIcon from '../icons/AlertSuccessIcon';
import AlertWarnIcon from '../icons/AlertWarnIcon';
`;
function getAlertVariantInfo(variant: AlertVariant): AlertVariantInformation {
- const variantList:
T.Dict<AlertVariantInformation> = {
+ const variantList: Dict<AlertVariantInformation> = {
error: {
icon: <AlertErrorIcon fill={colors.alertIconError} />,
color: colors.alertTextError,
import { translate } from '../../helpers/l10n';
import { EditionKey } from '../../types/editions';
import { SystemUpgrade } from '../../types/system';
+import { AppState } from '../../types/types';
import { ResetButtonLink } from '../controls/buttons';
import Modal from '../controls/Modal';
import { withAppState } from '../hoc/withAppState';
import { UpdateUseCase } from './utils';
interface Props {
- appState: Pick<T.AppState, 'edition' | 'version'>;
+ appState: Pick<AppState, 'edition' | 'version'>;
onClose: () => void;
systemUpgrades: SystemUpgrade[][];
latestLTS: string;
import * as React from 'react';
import { getRulesApp } from '../../api/rules';
import { get, save } from '../../helpers/storage';
+import { Dict } from '../../types/types';
import { lazyLoadComponent } from '../lazyLoadComponent';
import { ComponentDescriptor, RuleDescriptor, WorkspaceContext } from './context';
import './styles.css';
interface State {
components: ComponentDescriptor[];
- externalRulesRepoNames: T.Dict<string>;
+ externalRulesRepoNames: Dict<string>;
height: number;
maximized?: boolean;
open: { component?: string; rule?: string };
fetchRuleNames = async () => {
const { repositories } = await getRulesApp();
- const externalRulesRepoNames: T.Dict<string> = {};
+ const externalRulesRepoNames: Dict<string> = {};
repositories
.filter(({ key }) => key.startsWith('external_'))
.forEach(({ key, name }) => {
import { scrollToElement } from '../../helpers/scrolling';
import { fetchBranchStatus } from '../../store/rootActions';
import { BranchLike } from '../../types/branch-like';
+import { Issue, SourceViewerFile } from '../../types/types';
import SourceViewer from '../SourceViewer/SourceViewer';
import { ComponentDescriptor } from './context';
import WorkspaceComponentTitle from './WorkspaceComponentTitle';
import WorkspaceHeader, { Props as WorkspaceHeaderProps } from './WorkspaceHeader';
-export interface Props extends T.Omit<WorkspaceHeaderProps, 'children' | 'onClose'> {
+export interface Props extends Omit<WorkspaceHeaderProps, 'children' | 'onClose'> {
component: ComponentDescriptor;
fetchBranchStatus: (branchLike: BranchLike, projectKey: string) => Promise<void>;
height: number;
this.props.onClose(this.props.component.key);
};
- handleIssueChange = (_: T.Issue) => {
+ handleIssueChange = (_: Issue) => {
this.refreshBranchStatus();
};
- handleLoaded = (component: T.SourceViewerFile) => {
+ handleLoaded = (component: SourceViewerFile) => {
this.props.onLoad({
key: this.props.component.key,
name: component.path,
import RuleDetailsMeta from '../../apps/coding-rules/components/RuleDetailsMeta';
import '../../apps/coding-rules/styles.css';
import DeferredSpinner from '../../components/ui/DeferredSpinner';
+import { Dict, RuleDetails } from '../../types/types';
interface Props {
onLoad: (details: { name: string }) => void;
interface State {
loading: boolean;
- referencedRepositories: T.Dict<{ key: string; language: string; name: string }>;
- ruleDetails?: T.RuleDetails;
+ referencedRepositories: Dict<{ key: string; language: string; name: string }>;
+ ruleDetails?: RuleDetails;
}
export default class WorkspaceRuleDetails extends React.PureComponent<Props, State> {
import WorkspaceRuleDetails from './WorkspaceRuleDetails';
import WorkspaceRuleTitle from './WorkspaceRuleTitle';
-export interface Props extends T.Omit<WorkspaceHeaderProps, 'children' | 'onClose'> {
+export interface Props extends Omit<WorkspaceHeaderProps, 'children' | 'onClose'> {
rule: RuleDescriptor;
height: number;
onClose: (componentKey: string) => void;
*/
import { createContext } from 'react';
import { BranchLike } from '../../types/branch-like';
+import { Dict } from '../../types/types';
export interface ComponentDescriptor {
branchLike: BranchLike | undefined;
}
export interface WorkspaceContextShape {
- externalRulesRepoNames: T.Dict<string>;
+ externalRulesRepoNames: Dict<string>;
openComponent: (component: ComponentDescriptor) => void;
openRule: (rule: RuleDescriptor) => void;
}
/* eslint-disable no-await-in-loop */
+import { Dict } from '../../types/types';
import handleRequiredAuthentication from '../handleRequiredAuthentication';
import {
checkStatus,
});
});
-function mockResponse(headers: T.Dict<string> = {}, status = HttpStatus.Ok, value?: any): Response {
+function mockResponse(headers: Dict<string> = {}, status = HttpStatus.Ok, value?: any): Response {
const body = value && value instanceof Object ? JSON.stringify(value) : value;
const response = new Response(body, { headers, status });
response.json = jest.fn().mockResolvedValue(value);
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+import { ComponentMeasure, ComponentMeasureEnhanced } from '../types/types';
+
export function getComponentMeasureUniqueKey(
- component?: T.ComponentMeasure | T.ComponentMeasureEnhanced
+ component?: ComponentMeasure | ComponentMeasureEnhanced
) {
return component ? [component.key, component.branch].filter(s => !!s).join('/') : undefined;
}
import { AlmKeys } from '../types/alm-settings';
import { ComponentQualifier } from '../types/component';
import { IssueScope, IssueType } from '../types/issues';
+import { RuleType } from '../types/types';
export const SEVERITIES = ['BLOCKER', 'CRITICAL', 'MAJOR', 'MINOR', 'INFO'];
export const STATUSES = ['OPEN', 'REOPENED', 'CONFIRMED', 'RESOLVED', 'CLOSED'];
-export const ISSUE_TYPES: T.IssueType[] = [
+export const ISSUE_TYPES: IssueType[] = [
IssueType.Bug,
IssueType.Vulnerability,
IssueType.CodeSmell,
{ scope: IssueScope.Main, qualifier: ComponentQualifier.File },
{ scope: IssueScope.Test, qualifier: ComponentQualifier.TestFile }
];
-export const RULE_TYPES: T.RuleType[] = ['BUG', 'VULNERABILITY', 'CODE_SMELL', 'SECURITY_HOTSPOT'];
+export const RULE_TYPES: RuleType[] = ['BUG', 'VULNERABILITY', 'CODE_SMELL', 'SECURITY_HOTSPOT'];
export const RULE_STATUSES = ['READY', 'BETA', 'DEPRECATED'];
export const CHART_COLORS_RANGE_PERCENT = [
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { memoize } from 'lodash';
+import { Dict } from '../types/types';
const parseCookies = memoize(
- (documentCookie: string): T.Dict<string> => {
+ (documentCookie: string): Dict<string> => {
const rawCookies = documentCookie.split('; ');
- const cookies: T.Dict<string> = {};
+ const cookies: Dict<string> = {};
rawCookies.forEach(candidate => {
const [key, value] = candidate.split('=');
cookies[key] = value;
// Do not import dependencies in this helper, to keep initial bundle load as small as possible
import { ExtensionRegistryEntry, ExtensionStartMethod } from '../types/extension';
+import { Dict } from '../types/types';
import { getEnhancedWindow } from './browser';
const WEB_ANALYTICS_EXTENSION = 'sq-web-analytics';
-const extensions: T.Dict<ExtensionRegistryEntry> = {};
+const extensions: Dict<ExtensionRegistryEntry> = {};
function registerExtension(key: string, start: ExtensionStartMethod, providesCSSFile = false) {
extensions[key] = { start, providesCSSFile };
import VulnerabilityIcon from '../components/icons/VulnerabilityIcon';
import { IssueType, RawIssue } from '../types/issues';
import { MetricKey } from '../types/metrics';
+import { Dict, FlowLocation, Issue, TextRange, UserBase } from '../types/types';
import { ISSUE_TYPES } from './constants';
interface Rule {}
name: string;
}
-export function sortByType<T extends Pick<T.Issue, 'type'>>(issues: T[]): T[] {
- return sortBy(issues, issue => ISSUE_TYPES.indexOf(issue.type));
+export function sortByType<T extends Pick<Issue, 'type'>>(issues: T[]): T[] {
+ return sortBy(issues, issue => ISSUE_TYPES.indexOf(issue.type as IssueType));
}
function injectRelational(
+ issue: Dict<any>,
source: any[] | undefined,
baseField: string,
lookupField: string
) {
- const newFields:
T.Dict<any> = {};
+ const newFields: Dict<any> = {};
const baseValue = issue[baseField];
if (baseValue !== undefined && source !== undefined) {
const lookupValue = source.find(candidate => candidate[lookupField] === baseValue);
return newFields;
}
-function injectCommentsRelational(issue: RawIssue, users?: T.UserBase[]) {
+function injectCommentsRelational(issue: RawIssue, users?: UserBase[]) {
if (!issue.comments) {
return {};
}
function prepareClosed(
issue: RawIssue,
- secondaryLocations: T.FlowLocation[],
- flows: T.FlowLocation[][]
+ secondaryLocations: FlowLocation[],
+ flows: FlowLocation[][]
) {
return issue.status === 'CLOSED'
? { flows: [], line: undefined, textRange: undefined, secondaryLocations: [] }
: { flows, secondaryLocations };
}
-function ensureTextRange(issue: RawIssue): { textRange?: T.TextRange } {
+function ensureTextRange(issue: RawIssue): { textRange?: TextRange } {
return issue.line && !issue.textRange
? {
textRange: {
: {};
}
-function reverseLocations(locations: T.FlowLocation[]): T.FlowLocation[] {
+function reverseLocations(locations: FlowLocation[]): FlowLocation[] {
const x = [...locations];
x.reverse();
return x;
function splitFlows(
issue: RawIssue,
components: Component[] = []
-): { secondaryLocations: T.FlowLocation[]; flows: T.FlowLocation[][] } {
- const parsedFlows: T.FlowLocation[][] = (issue.flows || [])
+): { secondaryLocations: FlowLocation[]; flows: FlowLocation[][] } {
+ const parsedFlows: FlowLocation[][] = (issue.flows || [])
.filter(flow => flow.locations !== undefined)
.map(flow => flow.locations!.filter(location => location.textRange != null))
.map(flow =>
: { secondaryLocations: [], flows: parsedFlows.map(reverseLocations) };
}
-function orderLocations(locations: T.FlowLocation[]) {
+function orderLocations(locations: FlowLocation[]) {
return sortBy(
locations,
location => location.textRange && location.textRange.startLine,
export function parseIssueFromResponse(
issue: RawIssue,
components?: Component[],
- users?: T.UserBase[],
+ users?: UserBase[],
rules?: Rule[]
-): T.Issue {
+): Issue {
const { secondaryLocations, flows } = splitFlows(issue, components);
return {
...issue,
...injectCommentsRelational(issue, users),
...prepareClosed(issue, secondaryLocations, flows),
...ensureTextRange(issue)
- } as T.Issue;
+ } as Issue;
}
export const ISSUETYPE_METRIC_KEYS_MAP = {
*/
import { fetchL10nBundle } from '../api/l10n';
import { L10nBundle, L10nBundleRequestParams } from '../types/l10n';
+import { Dict } from '../types/types';
import { toNotSoISOString } from './dates';
import { get as loadFromLocalStorage, save as saveInLocalStorage } from './storage';
-export type Messages = T.Dict<string>;
+export type Messages = Dict<string>;
export const DEFAULT_LOCALE = 'en';
export const DEFAULT_MESSAGES = {
QualityGateStatusCondition,
QualityGateStatusConditionEnhanced
} from '../types/quality-gates';
+import { Dict, Measure, MeasureEnhanced, Metric } from '../types/types';
import { getCurrentLocale, translate, translateWithParameters } from './l10n';
import { isDefined } from './types';
export function enhanceMeasuresWithMetrics(
- measures: T.Measure[],
- metrics: T.Metric[]
-): T.MeasureEnhanced[] {
+ measures: Measure[],
+ metrics: Metric[]
+): MeasureEnhanced[] {
return measures
.map(measure => {
const metric = metrics.find(metric => metric.key === measure.metric);
export function enhanceConditionWithMeasure(
condition: QualityGateStatusCondition,
- measures: T.MeasureEnhanced[]
+ measures: MeasureEnhanced[]
): QualityGateStatusConditionEnhanced | undefined {
const measure = measures.find(m => m.metric.key === condition.metric);
return measure && { ...condition, period, measure };
}
-export function isPeriodBestValue(measure: T.Measure | T.MeasureEnhanced): boolean {
+export function isPeriodBestValue(measure: Measure | MeasureEnhanced): boolean {
return measure.period?.bestValue || false;
}
: translate('metric', finalMetricKey, 'tooltip', ratingLetter);
}
-export function getDisplayMetrics(metrics: T.Metric[]) {
+export function getDisplayMetrics(metrics: Metric[]) {
return metrics.filter(metric => !metric.hidden && !['DATA', 'DISTRIB'].includes(metric.type));
}
-export function findMeasure(measures: T.MeasureEnhanced[], metric: MetricKey | string) {
+export function findMeasure(measures: MeasureEnhanced[], metric: MetricKey | string) {
return measures.find(measure => measure.metric.key === metric);
}
}
function getFormatter(type: string): Formatter {
- const FORMATTERS: T.Dict<Formatter> = {
+ const FORMATTERS: Dict<Formatter> = {
INT: intFormatter,
SHORT_INT: shortIntFormatter,
FLOAT: floatFormatter,
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-import { ComponentQualifier, TreeComponent } from '../../types/component';
+import { ComponentQualifier, TreeComponent, Visibility } from '../../types/component';
import { MetricKey } from '../../types/metrics';
+import { Component, ComponentMeasure, ComponentMeasureEnhanced } from '../../types/types';
import { mockMeasureEnhanced } from '../testMocks';
-export function mockComponent(overrides: Partial<T.Component> = {}): T.Component {
+export function mockComponent(overrides: Partial<Component> = {}): Component {
return {
breadcrumbs: [],
key: 'my-project',
key: 'my-key',
qualifier: ComponentQualifier.Project,
name: 'component',
- visibility: 'public',
+ visibility: Visibility.Public,
...overrides
};
}
export function mockComponentMeasure(
file = false,
- overrides: Partial<T.ComponentMeasure> = {}
-): T.ComponentMeasure {
+ overrides: Partial<ComponentMeasure> = {}
+): ComponentMeasure {
if (file) {
return {
key: 'foo:src/index.tsx',
}
export function mockComponentMeasureEnhanced(
- overrides: Partial<T.ComponentMeasureEnhanced> = {}
-): T.ComponentMeasureEnhanced {
+ overrides: Partial<ComponentMeasureEnhanced> = {}
+): ComponentMeasureEnhanced {
return {
- ...mockComponentMeasure(false, overrides as T.ComponentMeasure),
+ ...mockComponentMeasure(false, overrides as ComponentMeasure),
leak: undefined,
measures: [mockMeasureEnhanced()],
value: undefined,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { ReferencedRule } from '../../types/issues';
+import { IssueChangelog } from '../../types/types';
export function mockReferencedRule(overrides: Partial<ReferencedRule> = {}): ReferencedRule {
return {
};
}
-export function mockIssueChangelog(overrides: Partial<T.IssueChangelog> = {}): T.IssueChangelog {
+export function mockIssueChangelog(overrides: Partial<IssueChangelog> = {}): IssueChangelog {
return {
creationDate: '2018-10-01',
isUserActive: true,
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+import { PermissionGroup, PermissionUser } from '../../types/types';
import { mockUser } from '../testMocks';
-export function mockPermissionGroup(overrides: Partial<T.PermissionGroup> = {}): T.PermissionGroup {
+export function mockPermissionGroup(overrides: Partial<PermissionGroup> = {}): PermissionGroup {
return {
name: 'sonar-admins',
permissions: ['provisioning'],
};
}
-export function mockPermissionUser(overrides: Partial<T.PermissionUser> = {}): T.PermissionUser {
+export function mockPermissionUser(overrides: Partial<PermissionUser> = {}): PermissionUser {
return {
...mockUser(),
active: true,
QualityGateStatusCondition,
QualityGateStatusConditionEnhanced
} from '../../types/quality-gates';
+import { QualityGate } from '../../types/types';
import { mockMeasureEnhanced, mockMetric } from '../testMocks';
-export function mockQualityGate(overrides: Partial<T.QualityGate> = {}): T.QualityGate {
+export function mockQualityGate(overrides: Partial<QualityGate> = {}): QualityGate {
return {
id: '1',
name: 'qualitygate',
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-export function mockUserBase(overrides: Partial<T.UserBase> = {}): T.UserBase {
+import { UserBase } from '../../types/types';
+
+export function mockUserBase(overrides: Partial<UserBase> = {}): UserBase {
return {
login: 'userlogin',
...overrides
import { parseDate } from '../helpers/dates';
import { translate, translateWithParameters } from '../helpers/l10n';
import { ApplicationPeriod } from '../types/application';
+import { Period } from '../types/types';
export function getPeriodLabel(
- period: T.Period | undefined,
+ period: Period | undefined,
dateFormatter: (date: string) => string
) {
if (!period) {
}
export function isApplicationPeriod(
- period: T.Period | ApplicationPeriod
+ period: Period | ApplicationPeriod
): period is ApplicationPeriod {
return (period as ApplicationPeriod).project !== undefined;
}
*/
import { partition, sortBy } from 'lodash';
import { translate } from '../helpers/l10n';
+import { ProjectLink } from '../types/types';
const PROVIDED_TYPES = ['homepage', 'ci', 'issue', 'scm', 'scm_dev'];
-type NameAndType = Pick<T.ProjectLink, 'name' | 'type'>;
+type NameAndType = Pick<ProjectLink, 'name' | 'type'>;
-export function isProvided(link: Pick<T.ProjectLink, 'type'>) {
+export function isProvided(link: Pick<ProjectLink, 'type'>) {
return PROVIDED_TYPES.includes(link.type);
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { isEqual, isNil, omitBy } from 'lodash';
+import { RawQuery } from '../types/types';
import { isValidDate, parseDate, toNotSoISOString, toShortNotSoISOString } from './dates';
-export function queriesEqual(a: T.RawQuery, b: T.RawQuery): boolean {
+export function queriesEqual(a: RawQuery, b: RawQuery): boolean {
const keysA = Object.keys(a);
const keysB = Object.keys(b);
return keysA.every(key => isEqual(a[key], b[key]));
}
-export function cleanQuery(query: T.RawQuery): T.RawQuery {
+export function cleanQuery(query: RawQuery): RawQuery {
return omitBy(query, isNil);
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { isNil, omitBy } from 'lodash';
+import { Dict } from '../types/types';
import { getCookie } from './cookies';
import { translate } from './l10n';
import { stringify } from './stringify-queryparams';
/**
* Return an object containing a special http request header used to prevent CSRF attacks.
*/
-export function getCSRFToken(): T.Dict<string> {
+export function getCSRFToken(): Dict<string> {
// Fetch API in Edge doesn't work with empty header,
// so we ensure non-empty value
const value = getCSRFTokenValue();
return value ? { [getCSRFTokenName()]: value } : {};
}
-export type RequestData =
T.Dict<any>;
+export type RequestData = Dict<any>;
export function omitNil(obj: RequestData): RequestData {
return omitBy(obj, isNil);
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+
+import { Dict } from '../types/types';
+
/*
* Latinize string by removing all diacritics
* From http://stackoverflow.com/questions/990904/javascript-remove-accents-in-strings
}
];
-const diacriticsMap: T.Dict<string> = {};
+const diacriticsMap: Dict<string> = {};
defaultDiacriticsRemovalap.forEach(defaultDiacritic =>
defaultDiacritic.letters.split('').forEach(letter => {
diacriticsMap[letter] = defaultDiacritic.base;
import { Exporter, Profile } from '../apps/quality-profiles/types';
import { DumpStatus, DumpTask } from '../types/project-dump';
import { TaskStatuses } from '../types/tasks';
-
-export function mockAlmApplication(overrides: Partial<T.AlmApplication> = {}): T.AlmApplication {
+import {
+ AlmApplication,
+ Analysis,
+ AnalysisEvent,
+ AppState,
+ Condition,
+ CurrentUser,
+ FlowLocation,
+ Group,
+ HealthType,
+ IdentityProvider,
+ Issue,
+ Language,
+ LoggedInUser,
+ Measure,
+ MeasureEnhanced,
+ Metric,
+ Paging,
+ ParsedAnalysis,
+ Period,
+ ProfileInheritanceDetails,
+ Rule,
+ RuleActivation,
+ RuleDetails,
+ RuleParameter,
+ SnippetsByComponent,
+ SourceLine,
+ SourceViewerFile,
+ SysInfoBase,
+ SysInfoCluster,
+ SysInfoStandalone,
+ User
+} from '../types/types';
+
+export function mockAlmApplication(overrides: Partial<AlmApplication> = {}): AlmApplication {
return {
backgroundColor: '#444444',
iconPath: '/images/sonarcloud/github-white.svg',
};
}
-export function mockAnalysis(overrides: Partial<T.Analysis> = {}): T.Analysis {
+export function mockAnalysis(overrides: Partial<Analysis> = {}): Analysis {
return {
date: '2017-03-01T09:36:01+0100',
events: [],
};
}
-export function mockParsedAnalysis(overrides: Partial<T.ParsedAnalysis> = {}): T.ParsedAnalysis {
+export function mockParsedAnalysis(overrides: Partial<ParsedAnalysis> = {}): ParsedAnalysis {
return {
date: new Date('2017-03-01T09:37:01+0100'),
events: [],
};
}
-export function mockAnalysisEvent(overrides: Partial<T.AnalysisEvent> = {}): T.AnalysisEvent {
+export function mockAnalysisEvent(overrides: Partial<AnalysisEvent> = {}): AnalysisEvent {
return {
category: 'QUALITY_GATE',
key: 'E11',
};
}
-export function mockAppState(overrides: Partial<T.AppState> = {}): T.AppState {
+export function mockAppState(overrides: Partial<AppState> = {}): AppState {
return {
edition: 'community',
productionDatabase: true,
};
}
-export function mockBaseSysInfo(overrides: Partial<any> = {}): T.SysInfoBase {
+export function mockBaseSysInfo(overrides: Partial<any> = {}): SysInfoBase {
return {
- Health: 'GREEN' as T.HealthType,
+ Health: 'GREEN' as HealthType,
'Health Causes': [],
System: {
Version: '7.8'
};
}
-export function mockClusterSysInfo(overrides: Partial<any> = {}): T.SysInfoCluster {
+export function mockClusterSysInfo(overrides: Partial<any> = {}): SysInfoCluster {
const baseInfo = mockBaseSysInfo(overrides);
return {
...baseInfo,
{
Name: 'server9.example.com',
Host: '10.0.0.0',
- Health: 'GREEN' as T.HealthType,
+ Health: 'GREEN' as HealthType,
'Health Causes': [],
System: {
Version: '7.8'
{
Name: 'server9.example.com',
Host: '10.0.0.0',
- Health: 'GREEN' as T.HealthType,
+ Health: 'GREEN' as HealthType,
'Health Causes': [],
System: {
Version: '7.8'
};
}
-export function mockCondition(overrides: Partial<T.Condition> = {}): T.Condition {
+export function mockCondition(overrides: Partial<Condition> = {}): Condition {
return {
error: '10',
id: 1,
export function mockSnippetsByComponent(
component = 'main.js',
lines: number[] = [16]
-): T.SnippetsByComponent {
- const sources = lines.reduce((lines: { [key: number]: T.SourceLine }, line) => {
+): SnippetsByComponent {
+ const sources = lines.reduce((lines: { [key: number]: SourceLine }, line) => {
lines[line] = mockSourceLine({ line });
return lines;
}, {});
};
}
-export function mockSourceLine(overrides: Partial<T.SourceLine> = {}): T.SourceLine {
+export function mockSourceLine(overrides: Partial<SourceLine> = {}): SourceLine {
return {
line: 16,
code: '<span class="k">import</span> java.util.<span class="sym-9 sym">ArrayList</span>;',
};
}
-export function mockCurrentUser(overrides: Partial<T.CurrentUser> = {}): T.CurrentUser {
+export function mockCurrentUser(overrides: Partial<CurrentUser> = {}): CurrentUser {
return {
isLoggedIn: false,
...overrides
};
}
-export function mockLoggedInUser(overrides: Partial<T.LoggedInUser> = {}): T.LoggedInUser {
+export function mockLoggedInUser(overrides: Partial<LoggedInUser> = {}): LoggedInUser {
return {
groups: [],
isLoggedIn: true,
};
}
-export function mockGroup(overrides: Partial<T.Group> = {}): T.Group {
+export function mockGroup(overrides: Partial<Group> = {}): Group {
return {
id: 1,
membersCount: 1,
} as any;
}
-export function mockIssue(withLocations = false, overrides: Partial<T.Issue> = {}) {
- const issue: T.Issue = {
+export function mockIssue(withLocations = false, overrides: Partial<Issue> = {}) {
+ const issue: Issue = {
actions: [],
component: 'main.js',
componentLongName: 'main.js',
};
}
-export function mockMetric(
- overrides: Partial<Pick<T.Metric, 'key' | 'name' | 'type'>> = {}
-): T.Metric {
+export function mockMetric(overrides: Partial<Pick<Metric, 'key' | 'name' | 'type'>> = {}): Metric {
const key = overrides.key || 'coverage';
const name = overrides.name || key[0].toUpperCase() + key.substr(1);
const type = overrides.type || 'PERCENT';
};
}
-export function mockMeasure(overrides: Partial<T.Measure> = {}): T.Measure {
+export function mockMeasure(overrides: Partial<Measure> = {}): Measure {
return {
bestValue: true,
metric: 'bugs',
};
}
-export function mockMeasureEnhanced(overrides: Partial<T.MeasureEnhanced> = {}): T.MeasureEnhanced {
+export function mockMeasureEnhanced(overrides: Partial<MeasureEnhanced> = {}): MeasureEnhanced {
return {
bestValue: true,
leak: '1',
};
}
-export function mockPeriod(overrides: Partial<T.Period> = {}): T.Period {
+export function mockPeriod(overrides: Partial<Period> = {}): Period {
return {
date: '2019-04-23T02:12:32+0100',
index: 0,
}
export function mockQualityProfileInheritance(
- overrides: Partial<T.ProfileInheritanceDetails> = {}
-): T.ProfileInheritanceDetails {
+ overrides: Partial<ProfileInheritanceDetails> = {}
+): ProfileInheritanceDetails {
return {
activeRuleCount: 4,
isBuiltIn: false,
} as InjectedRouter;
}
-export function mockRule(overrides: Partial<T.Rule> = {}): T.Rule {
+export function mockRule(overrides: Partial<Rule> = {}): Rule {
return {
key: 'javascript:S1067',
lang: 'js',
tags: ['x'],
type: 'CODE_SMELL',
...overrides
- } as T.Rule;
+ } as Rule;
}
-export function mockRuleActivation(overrides: Partial<T.RuleActivation> = {}): T.RuleActivation {
+export function mockRuleActivation(overrides: Partial<RuleActivation> = {}): RuleActivation {
return {
createdAt: '2020-02-01',
inherit: 'NONE',
};
}
-export function mockRuleDetails(overrides: Partial<T.RuleDetails> = {}): T.RuleDetails {
+export function mockRuleDetails(overrides: Partial<RuleDetails> = {}): RuleDetails {
return {
key: 'squid:S1337',
repo: 'squid',
};
}
-export function mockRuleDetailsParameter(
- overrides: Partial<T.RuleParameter> = {}
-): T.RuleParameter {
+export function mockRuleDetailsParameter(overrides: Partial<RuleParameter> = {}): RuleParameter {
return {
defaultValue: '1',
htmlDesc: 'description',
};
}
-export function mockSourceViewerFile(
- overrides: Partial<T.SourceViewerFile> = {}
-): T.SourceViewerFile {
+export function mockSourceViewerFile(overrides: Partial<SourceViewerFile> = {}): SourceViewerFile {
return {
key: 'foo',
measures: {
};
}
-export function mockStandaloneSysInfo(overrides: Partial<any> = {}): T.SysInfoStandalone {
+export function mockStandaloneSysInfo(overrides: Partial<any> = {}): SysInfoStandalone {
const baseInfo = mockBaseSysInfo(overrides);
return {
...baseInfo,
return createStore(reducer, state);
}
-export function mockUser(overrides: Partial<T.User> = {}): T.User {
+export function mockUser(overrides: Partial<User> = {}): User {
return {
active: true,
local: true,
};
}
-export function mockLanguage(overrides: Partial<T.Language> = {}): T.Language {
+export function mockLanguage(overrides: Partial<Language> = {}): Language {
return {
key: 'css',
name: 'CSS',
};
}
-export function mockFlowLocation(overrides: Partial<T.FlowLocation> = {}): T.FlowLocation {
+export function mockFlowLocation(overrides: Partial<FlowLocation> = {}): FlowLocation {
return {
component: 'main.js',
textRange: {
};
}
-export function mockIdentityProvider(
- overrides: Partial<T.IdentityProvider> = {}
-): T.IdentityProvider {
+export function mockIdentityProvider(overrides: Partial<IdentityProvider> = {}): IdentityProvider {
return {
backgroundColor: '#000000',
iconPath: '/path/icon.svg',
} as React.RefObject<HTMLElement>;
}
-export function mockPaging(overrides: Partial<T.Paging> = {}): T.Paging {
+export function mockPaging(overrides: Partial<Paging> = {}): Paging {
return {
pageIndex: 1,
pageSize: 100,
import { MeasurePageView } from '../types/measures';
import { GraphType } from '../types/project-activity';
import { SecurityStandard } from '../types/security';
+import { Dict, HomePage } from '../types/types';
import { getBranchLikeQuery, isBranch, isMainBranch, isPullRequest } from './branch-like';
import { IS_SSR } from './browser';
import { getBaseUrl } from './system';
export interface Location {
pathname: string;
- query?: T.Dict<string | undefined | number>;
+ query?: Dict<string | undefined | number>;
}
type Query = Location['query'];
export function getGlobalSettingsUrl(
category?: string,
- query?: T.Dict<string | undefined | number>
+ query?: Dict<string | undefined | number>
): Location {
return {
pathname: '/admin/settings',
};
}
-export function getHomePageUrl(homepage: T.HomePage) {
+export function getHomePageUrl(homepage: HomePage) {
switch (homepage.type) {
case 'APPLICATION':
return homepage.branch
+import { CurrentUser, LoggedInUser, UserActive, UserBase } from '../types/types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-export function hasGlobalPermission(user: T.CurrentUser, permission: string): boolean {
+export function hasGlobalPermission(user: CurrentUser, permission: string): boolean {
if (!user.permissions) {
return false;
}
return user.permissions.global.includes(permission);
}
-export function isLoggedIn(user: T.CurrentUser): user is T.LoggedInUser {
+export function isLoggedIn(user: CurrentUser): user is LoggedInUser {
return user.isLoggedIn;
}
-export function isUserActive(user: T.UserBase): user is T.UserActive {
+export function isUserActive(user: UserBase): user is UserActive {
return user.active !== false && Boolean(user.name);
}
import { mockQualityGateStatusCondition } from '../../helpers/mocks/quality-gates';
import { BranchLike } from '../../types/branch-like';
import { QualityGateStatusCondition } from '../../types/quality-gates';
+import { Status } from '../../types/types';
import reducer, {
getBranchStatusByBranchLike,
registerBranchStatusAction,
State
} from '../branches';
-type TestArgs = [BranchLike, string, T.Status, QualityGateStatusCondition[], boolean?];
+type TestArgs = [BranchLike, string, Status, QualityGateStatusCondition[], boolean?];
const FAILING_CONDITION = mockQualityGateStatusCondition();
const COMPONENT = 'foo';
import { mockCurrentUser, mockLoggedInUser, mockUser } from '../../helpers/testMocks';
import { isLoggedIn } from '../../helpers/users';
+import { CurrentUserSetting, HomePage, LoggedInUser } from '../../types/types';
import reducer, {
getCurrentUser,
getCurrentUserSetting,
});
it('should allow to set the homepage', () => {
- const homepage: T.HomePage = { type: 'PROJECTS' };
+ const homepage: HomePage = { type: 'PROJECTS' };
const currentUser = mockLoggedInUser({ homepage: undefined });
const initialState: State = createState({ currentUser });
const newState = reducer(initialState, setHomePageAction(homepage));
expect(newState).toEqual(
- createState({ currentUser: { ...currentUser, homepage } as T.LoggedInUser })
+ createState({ currentUser: { ...currentUser, homepage } as LoggedInUser })
);
});
it('should allow to set a user setting', () => {
- const setting1: T.CurrentUserSetting = { key: 'notifications.optOut', value: '1' };
- const setting2: T.CurrentUserSetting = { key: 'notifications.readDate', value: '2' };
- const setting3: T.CurrentUserSetting = { key: 'notifications.optOut', value: '2' };
+ const setting1: CurrentUserSetting = { key: 'notifications.optOut', value: '1' };
+ const setting2: CurrentUserSetting = { key: 'notifications.readDate', value: '2' };
+ const setting3: CurrentUserSetting = { key: 'notifications.optOut', value: '2' };
const currentUser = mockLoggedInUser();
const initialState: State = createState({ currentUser });
const newState = reducer(initialState, setCurrentUserSettingAction(setting1));
expect(newState).toEqual(
- createState({ currentUser: { ...currentUser, settings: [setting1] } as T.LoggedInUser })
+ createState({ currentUser: { ...currentUser, settings: [setting1] } as LoggedInUser })
);
const newerState = reducer(newState, setCurrentUserSettingAction(setting2));
expect(newerState).toEqual(
createState({
- currentUser: { ...currentUser, settings: [setting1, setting2] } as T.LoggedInUser
+ currentUser: { ...currentUser, settings: [setting1, setting2] } as LoggedInUser
})
);
const newestState = reducer(newerState, setCurrentUserSettingAction(setting3));
expect(newestState).toEqual(
createState({
- currentUser: { ...currentUser, settings: [setting3, setting2] } as T.LoggedInUser
+ currentUser: { ...currentUser, settings: [setting3, setting2] } as LoggedInUser
})
);
});
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+import { AppState, Extension } from '../types/types';
import { ActionType } from './utils/actions';
export const enum Actions {
| ActionType<typeof setAdminPages, Actions.SetAdminPages>
| ActionType<typeof requireAuthorization, Actions.RequireAuthorization>;
-export function setAppState(appState: T.AppState) {
+export function setAppState(appState: AppState) {
return { type: Actions.SetAppState, appState };
}
-export function setAdminPages(adminPages: T.Extension[]) {
+export function setAdminPages(adminPages: Extension[]) {
return { type: Actions.SetAdminPages, adminPages };
}
return { type: Actions.RequireAuthorization };
}
-const defaultValue: T.AppState = {
+const defaultValue: AppState = {
authenticationError: false,
authorizationError: false,
edition: undefined,
version: ''
};
-export default function(state: T.AppState = defaultValue, action: Action): T.AppState {
+export default function(state: AppState = defaultValue, action: Action): AppState {
if (action.type === Actions.SetAppState) {
return { ...state, ...action.appState };
}
import { getBranchLikeKey } from '../helpers/branch-like';
import { BranchLike } from '../types/branch-like';
import { QualityGateStatusCondition } from '../types/quality-gates';
+import { Dict, Status } from '../types/types';
import { ActionType } from './utils/actions';
export interface BranchStatusData {
conditions?: QualityGateStatusCondition[];
ignoredConditions?: boolean;
- status?: T.Status;
+ status?: Status;
}
export interface State {
- byComponent: T.Dict<T.Dict<BranchStatusData>>;
+ byComponent: Dict<Dict<BranchStatusData>>;
}
const enum Actions {
export function registerBranchStatusAction(
branchLike: BranchLike,
component: string,
- status: T.Status,
+ status: Status,
conditions?: QualityGateStatusCondition[],
ignoredConditions?: boolean
) {
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { keyBy } from 'lodash';
+import { Languages } from '../types/types';
import { ActionType } from './utils/actions';
export function receiveLanguages(languages: Array<{ key: string; name: string }>) {
type Action = ActionType<typeof receiveLanguages, 'RECEIVE_LANGUAGES'>;
-export default function(state: T.Languages = {}, action: Action): T.Languages {
+export default function(state: Languages = {}, action: Action): Languages {
if (action.type === 'RECEIVE_LANGUAGES') {
return keyBy(action.languages, 'key');
}
return state;
}
-export function getLanguages(state: T.Languages) {
+export function getLanguages(state: Languages) {
return state;
}
-export function getLanguageByKey(state: T.Languages, key: string) {
+export function getLanguageByKey(state: Languages, key: string) {
return state[key];
}
*/
import { keyBy } from 'lodash';
import { combineReducers } from 'redux';
+import { Dict, Metric } from '../types/types';
import { ActionType } from './utils/actions';
-export function receiveMetrics(metrics: T.Metric[]) {
+export function receiveMetrics(metrics: Metric[]) {
return { type: 'RECEIVE_METRICS', metrics };
}
type Action = ActionType<typeof receiveMetrics, 'RECEIVE_METRICS'>;
-export type State = { byKey: T.Dict<T.Metric>; keys: string[] };
+export type State = { byKey: Dict<Metric>; keys: string[] };
const byKey = (state: State['byKey'] = {}, action: Action) => {
if (action.type === 'RECEIVE_METRICS') {
import { getBranchLikeQuery } from '../helpers/branch-like';
import { extractStatusConditionsFromProjectStatus } from '../helpers/qualityGates';
import { BranchLike } from '../types/branch-like';
+import { Status } from '../types/types';
import { requireAuthorization as requireAuthorizationAction } from './appState';
import { registerBranchStatusAction } from './branches';
import { addGlobalErrorMessage } from './globalMessages';
return requireAuthorizationAction();
}
-export function registerBranchStatus(branchLike: BranchLike, component: string, status: T.Status) {
+export function registerBranchStatus(branchLike: BranchLike, component: string, status: Status) {
return (dispatch: Dispatch) => {
dispatch(registerBranchStatusAction(branchLike, component, status));
};
import { combineReducers } from 'redux';
import settingsApp, * as fromSettingsApp from '../apps/settings/store/rootReducer';
import { BranchLike } from '../types/branch-like';
+import { AppState, CurrentUserSettingNames, Languages } from '../types/types';
import appState from './appState';
import branches, * as fromBranches from './branches';
import globalMessages, * as fromGlobalMessages from './globalMessages';
import users, * as fromUsers from './users';
export type Store = {
- appState: T.AppState;
+ appState: AppState;
branches: fromBranches.State;
globalMessages: fromGlobalMessages.State;
- languages: T.Languages;
+ languages: Languages;
metrics: fromMetrics.State;
users: fromUsers.State;
return fromLanguages.getLanguages(state.languages);
}
-export function getCurrentUserSetting(state: Store, key: T.CurrentUserSettingNames) {
+export function getCurrentUserSetting(state: Store, key: CurrentUserSettingNames) {
return fromUsers.getCurrentUserSetting(state.users, key);
}
import { combineReducers, Dispatch } from 'redux';
import * as api from '../api/users';
import { isLoggedIn } from '../helpers/users';
+import {
+ CurrentUser,
+ CurrentUserSetting,
+ CurrentUserSettingNames,
+ Dict,
+ HomePage,
+ LoggedInUser
+} from '../types/types';
import { ActionType } from './utils/actions';
const enum Actions {
| ActionType<typeof setSonarlintAd, Actions.SetSonarlintAd>;
export interface State {
- usersByLogin:
T.Dict<any>;
+ usersByLogin: Dict<any>;
userLogins: string[];
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
}
-export function receiveCurrentUser(user: T.CurrentUser) {
+export function receiveCurrentUser(user: CurrentUser) {
return { type: Actions.ReceiveCurrentUser, user };
}
-export function setHomePageAction(homepage: T.HomePage) {
+export function setHomePageAction(homepage: HomePage) {
return { type: Actions.SetHomePageAction, homepage };
}
-export function setCurrentUserSettingAction(setting: T.CurrentUserSetting) {
+export function setCurrentUserSettingAction(setting: CurrentUserSetting) {
return { type: Actions.SetCurrentUserSetting, setting };
}
return { type: Actions.SetSonarlintAd };
}
-export function setHomePage(homepage: T.HomePage) {
+export function setHomePage(homepage: HomePage) {
return (dispatch: Dispatch) => {
api.setHomePage(homepage).then(
() => {
};
}
-export function setCurrentUserSetting(setting: T.CurrentUserSetting) {
+export function setCurrentUserSetting(setting: CurrentUserSetting) {
return (dispatch: Dispatch, getState: () => { users: State }) => {
const oldSetting = getCurrentUserSetting(getState().users, setting.key);
dispatch(setCurrentUserSettingAction(setting));
return action.user;
}
if (action.type === Actions.SetHomePageAction && isLoggedIn(state)) {
- return { ...state, homepage: action.homepage } as T.LoggedInUser;
+ return { ...state, homepage: action.homepage } as LoggedInUser;
}
if (action.type === Actions.SetCurrentUserSetting && isLoggedIn(state)) {
- let settings: T.CurrentUserSetting[];
+ let settings: CurrentUserSetting[];
if (state.settings) {
settings = [...state.settings];
const index = settings.findIndex(setting => setting.key === action.setting.key);
} else {
settings = [action.setting];
}
- return { ...state, settings } as T.LoggedInUser;
+ return { ...state, settings } as LoggedInUser;
}
if (action.type === Actions.SetSonarlintAd && isLoggedIn(state)) {
- return { ...state, sonarLintAdSeen: true } as T.LoggedInUser;
+ return { ...state, sonarLintAdSeen: true } as LoggedInUser;
}
return state;
}
return state.currentUser;
}
-export function getCurrentUserSetting(state: State, key: T.CurrentUserSettingNames) {
+export function getCurrentUserSetting(state: State, key: CurrentUserSettingNames) {
let setting;
if (isLoggedIn(state.currentUser) && state.currentUser.settings) {
setting = state.currentUser.settings.find(setting => setting.key === key);
*/
type ActionCreator = (...args: any[]) => { type: string };
-export type ActionType<F extends ActionCreator, T> = T.Omit<ReturnType<F>, 'type'> & { type: T };
+export type ActionType<F extends ActionCreator, T> = Omit<ReturnType<F>, 'type'> & { type: T };
+import { Dict } from './types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
workspace: string;
}
-export type BitbucketProjectRepositories = T.Dict<{
+export type BitbucketProjectRepositories = Dict<{
allShown: boolean;
repositories: BitbucketRepository[];
}>;
+import { NewCodePeriod, Status } from './types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
excludedFromPurge: boolean;
isMain: boolean;
name: string;
- status?: { qualityGateStatus: T.Status };
+ status?: { qualityGateStatus: Status };
}
export interface MainBranch extends Branch {
branch: string;
key: string;
isOrphan?: true;
- status?: { qualityGateStatus: T.Status };
+ status?: { qualityGateStatus: Status };
target: string;
title: string;
url?: string;
export type BranchParameters = { branch?: string } | { pullRequest?: string };
export interface BranchWithNewCodePeriod extends Branch {
- newCodePeriod?: T.NewCodePeriod;
+ newCodePeriod?: NewCodePeriod;
}
*/
import { ExtensionStartMethod } from './extension';
import { InstanceType } from './system';
+import { SysStatus } from './types';
export interface EnhancedWindow extends Window {
baseUrl: string;
- serverStatus: T.SysStatus;
+ serverStatus: SysStatus;
instance: InstanceType;
official: boolean;
+import { Dict, Rule, RuleActivation } from './types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
}
export interface SearchRulesResponse {
- actives?: T.Dict<T.RuleActivation[]>;
+ actives?: Dict<RuleActivation[]>;
facets?: { property: string; values: { count: number; val: string }[] }[];
p: number;
ps: number;
- rules: T.Rule[];
+ rules: Rule[];
total: number;
}
+import { LightComponent } from './types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
OnlyDigits = 'only_digits'
}
-export interface TreeComponent extends T.LightComponent {
+export interface TreeComponent extends LightComponent {
id?: string;
name: string;
path?: string;
refId?: string;
refKey?: string;
tags?: string[];
- visibility: T.Visibility;
+ visibility: Visibility;
}
export interface TreeComponentWithPath extends TreeComponent {
import { Location, Router } from '../components/hoc/withRouter';
import { Store } from '../store/rootReducer';
import { L10nBundle } from './l10n';
+import { CurrentUser, Dict } from './types';
export enum AdminPageExtension {
GovernanceConsole = 'governance/views_console'
export interface ExtensionStartMethodParameter {
store: ReduxStore<Store, any>;
el: HTMLElement | undefined | null;
- currentUser: T.CurrentUser;
+ currentUser: CurrentUser;
intl: IntlShape;
location: Location;
router: Router;
theme: {
- colors: T.Dict<string>;
- sizes: T.Dict<string>;
- rawSizes: T.Dict<number>;
- fonts: T.Dict<string>;
- zIndexes: T.Dict<string>;
- others: T.Dict<string>;
+ colors: Dict<string>;
+ sizes: Dict<string>;
+ rawSizes: Dict<number>;
+ fonts: Dict<string>;
+ zIndexes: Dict<string>;
+ others: Dict<string>;
};
baseUrl: string;
l10nBundle: L10nBundle;
+import { FlowLocation, Issue, Paging, TextRange, UserBase } from './types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
component: string;
flows?: Array<{
// `componentName` is not available in RawIssue
- locations?: Array<T.Omit<T.FlowLocation, 'componentName'>>;
+ locations?: Array<Omit<FlowLocation, 'componentName'>>;
}>;
key: string;
line?: number;
severity: string;
status: string;
subProject?: string;
- textRange?: T.TextRange;
+ textRange?: TextRange;
}
export interface IssueResponse {
components?: Array<{ key: string; name: string }>;
issue: RawIssue;
rules?: Array<{}>;
- users?: Array<T.UserBase>;
+ users?: Array<UserBase>;
}
export interface RawIssuesResponse {
facets: RawFacet[];
issues: RawIssue[];
languages: ReferencedLanguage[];
- paging: T.Paging;
+ paging: Paging;
rules?: Array<{}>;
- users?: Array<T.UserBase>;
+ users?: Array<UserBase>;
}
export interface FetchIssuesPromise {
components: ReferencedComponent[];
effortTotal: number;
facets: RawFacet[];
- issues: T.Issue[];
+ issues: Issue[];
languages: ReferencedLanguage[];
- paging: T.Paging;
+ paging: Paging;
rules: ReferencedRule[];
- users: T.UserBase[];
+ users: UserBase[];
}
export interface ReferencedComponent {
+import { Dict } from './types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
export interface L10nBundleRequestResponse {
effectiveLocale: string;
- messages: T.Dict<string>;
+ messages: Dict<string>;
}
export interface L10nBundle {
timestamp?: string;
locale?: string;
- messages?: T.Dict<string>;
+ messages?: Dict<string>;
}
+import { ComponentMeasure, Metric, Period, PeriodMeasure } from './types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
export interface MeasuresForProjects {
component: string;
metric: string;
- period?: T.PeriodMeasure;
+ period?: PeriodMeasure;
value?: string;
}
export interface MeasuresAndMetaWithMetrics {
- component: T.ComponentMeasure;
- metrics: T.Metric[];
+ component: ComponentMeasure;
+ metrics: Metric[];
}
export interface MeasuresAndMetaWithPeriod {
- component: T.ComponentMeasure;
- period: T.Period;
+ component: ComponentMeasure;
+ period: Period;
}
export type MeasurePageView = 'list' | 'tree' | 'treemap';
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { BranchLike } from './branch-like';
+import { MeasureEnhanced, Metric, Status, UserBase } from './types';
export interface QualityGateProjectStatus {
conditions?: QualityGateProjectStatusCondition[];
ignoredConditions: boolean;
- status: T.Status;
+ status: Status;
}
export interface QualityGateProjectStatusCondition {
errorThreshold: string;
metricKey: string;
periodIndex: number;
- status: T.Status;
+ status: Status;
}
export interface QualityGateApplicationStatus {
- metrics: T.Metric[];
+ metrics: Metric[];
projects: QualityGateApplicationStatusChildProject[];
- status: T.Status;
+ status: Status;
}
export interface QualityGateApplicationStatusCondition {
metric: string;
periodIndex?: number;
onLeak?: boolean;
- status: T.Status;
+ status: Status;
value: string;
warningThreshold?: string;
}
conditions: QualityGateApplicationStatusCondition[];
key: string;
name: string;
- status: T.Status;
+ status: Status;
}
export interface QualityGateStatus {
ignoredConditions?: boolean;
key: string;
name: string;
- status: T.Status;
+ status: Status;
branchLike?: BranchLike;
}
export interface QualityGateStatusCondition {
actual?: string;
error?: string;
- level: T.Status;
+ level: Status;
metric: string;
op: string;
period?: number;
}
export interface QualityGateStatusConditionEnhanced extends QualityGateStatusCondition {
- measure: T.MeasureEnhanced;
+ measure: MeasureEnhanced;
}
export interface SearchPermissionsParameters {
name: string;
}
-export function isUser(item: T.UserBase | Group): item is T.UserBase {
- return item && (item as T.UserBase).login !== undefined;
+export function isUser(item: UserBase | Group): item is UserBase {
+ return item && (item as UserBase).login !== undefined;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import { ComponentQualifier } from './component';
+import { IssueChangelog, IssueChangelogDiff, Paging, TextRange, UserBase } from './types';
export enum RiskExposure {
LOW = 'LOW',
export interface Hotspot {
assignee?: string;
- assigneeUser?: T.UserBase;
+ assigneeUser?: UserBase;
author: string;
- authorUser: T.UserBase;
+ authorUser: UserBase;
canChangeStatus: boolean;
- changelog: T.IssueChangelog[];
+ changelog: IssueChangelog[];
comment: HotspotComment[];
component: HotspotComponent;
creationDate: string;
resolution?: HotspotResolution;
rule: HotspotRule;
status: HotspotStatus;
- textRange?: T.TextRange;
+ textRange?: TextRange;
updateDate: string;
- users: T.UserBase[];
+ users: UserBase[];
}
export interface HotspotComponent {
updatable: boolean;
createdAt: string;
login: string;
- user: T.UserBase;
+ user: UserBase;
}
export interface ReviewHistoryElement {
type: ReviewHistoryType;
date: string;
- user: Pick<T.UserBase, 'active' | 'avatar' | 'name'>;
- diffs?: T.IssueChangelogDiff[];
+ user: Pick<UserBase, 'active' | 'avatar' | 'name'>;
+ diffs?: IssueChangelogDiff[];
html?: string;
key?: string;
updatable?: boolean;
export interface HotspotSearchResponse {
components?: { key: string; qualifier: string; name: string }[];
hotspots: RawHotspot[];
- paging: T.Paging;
+ paging: Paging;
}
export interface HotspotSetStatusRequest {
+import { Dict } from './types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
export type StandardType = SecurityStandard;
export type Standards = {
- [key in StandardType]: T.Dict<{ title: string; description?: string }>;
+ [key in StandardType]: Dict<{ title: string; description?: string }>;
};
+import { Dict } from './types';
+
/*
* SonarQube
* Copyright (C) 2009-2021 SonarSource SA
}
export interface SettingValue {
- fieldValues?: Array<T.Dict<string>>;
+ fieldValues?: Array<Dict<string>>;
inherited?: boolean;
key: string;
- parentFieldValues?: Array<T.Dict<string>>;
+ parentFieldValues?: Array<Dict<string>>;
parentValue?: string;
parentValues?: string[];
value?: string;
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2021 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-declare namespace T {
- // Type ordered alphabetically to prevent merge conflicts
- export type Dict<T> = { [key: string]: T };
- export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-
- export interface A11ySkipLink {
- key: string;
- label: string;
- weight?: number;
- }
-
- export interface AlmApplication extends IdentityProvider {
- installationUrl: string;
- }
-
- export interface AlmRepository {
- label: string;
- installationKey: string;
- linkedProjectKey?: string;
- linkedProjectName?: string;
- private?: boolean;
- }
-
- export interface AlmUnboundApplication {
- installationId: string;
- key: string;
- name: string;
- }
-
- interface BaseAnalysis {
- buildString?: string;
- detectedCI?: string;
- events: AnalysisEvent[];
- key: string;
- manualNewCodePeriodBaseline?: boolean;
- projectVersion?: string;
- }
-
- export interface Analysis extends BaseAnalysis {
- date: string;
- }
-
- export interface ParsedAnalysis extends BaseAnalysis {
- date: Date;
- }
-
- export interface AnalysisEvent {
- category: string;
- description?: string;
- key: string;
- name: string;
- qualityGate?: {
- failing: Array<{ branch: string; key: string; name: string }>;
- status: string;
- stillFailing: boolean;
- };
- definitionChange?: {
- projects: Array<{
- branch?: string;
- changeType: string;
- key: string;
- name: string;
- newBranch?: string;
- oldBranch?: string;
- }>;
- };
- }
-
- export interface AppState {
- adminPages?: Extension[];
- authenticationError?: boolean;
- authorizationError?: boolean;
- branchesEnabled?: boolean;
- canAdmin?: boolean;
- edition: 'community' | 'developer' | 'enterprise' | 'datacenter' | undefined;
- globalPages?: Extension[];
- projectImportFeatureEnabled?: boolean;
- instanceUsesDefaultAdminCredentials?: boolean;
- multipleAlmEnabled?: boolean;
- needIssueSync?: boolean;
- productionDatabase: boolean;
- qualifiers: string[];
- settings: T.Dict<string>;
- standalone?: boolean;
- version: string;
- webAnalyticsJsPath?: string;
- }
-
- export interface Breadcrumb {
- key: string;
- name: string;
- qualifier: string;
- }
-
- export namespace Chart {
- export interface Point {
- x: Date;
- y: number | string | undefined;
- }
-
- export interface Serie {
- data: Point[];
- name: string;
- translatedName: string;
- type: string;
- }
- }
-
- export interface Component extends LightComponent {
- alm?: { key: string; url: string };
- analysisDate?: string;
- breadcrumbs: Breadcrumb[];
- canBrowseAllChildProjects?: boolean;
- configuration?: ComponentConfiguration;
- description?: string;
- extensions?: Extension[];
- isFavorite?: boolean;
- leakPeriodDate?: string;
- name: string;
- needIssueSync?: boolean;
- path?: string;
- refKey?: string;
- qualityProfiles?: ComponentQualityProfile[];
- qualityGate?: { isDefault?: boolean; key: string; name: string };
- tags?: string[];
- version?: string;
- visibility?: Visibility;
- }
-
- interface ComponentConfiguration {
- canApplyPermissionTemplate?: boolean;
- canBrowseProject?: boolean;
- canUpdateProjectVisibilityToPrivate?: boolean;
- extensions?: Extension[];
- showBackgroundTasks?: boolean;
- showHistory?: boolean;
- showLinks?: boolean;
- showQualityGates?: boolean;
- showQualityProfiles?: boolean;
- showPermissions?: boolean;
- showSettings?: boolean;
- showUpdateKey?: boolean;
- }
-
- export interface ComponentQualityProfile {
- deleted?: boolean;
- key: string;
- language: string;
- name: string;
- }
-
- export interface ComponentMeasureIntern {
- branch?: string;
- description?: string;
- isFavorite?: boolean;
- isRecentlyBrowsed?: boolean;
- canBrowseAllChildProjects?: boolean;
- key: string;
- match?: string;
- name: string;
- path?: string;
- project?: string;
- qualifier: string;
- refKey?: string;
- }
-
- export interface ComponentMeasure extends ComponentMeasureIntern {
- measures?: Measure[];
- }
-
- export interface ComponentMeasureEnhanced extends ComponentMeasureIntern {
- value?: string;
- leak?: string;
- measures: MeasureEnhanced[];
- }
-
- export interface Condition {
- error: string;
- id: number;
- metric: string;
- op?: string;
- }
-
- export interface CoveredFile {
- key: string;
- longName: string;
- coveredLines: number;
- }
-
- export interface Coupon {
- billing?: {
- address?: string;
- country?: string;
- email?: string;
- name?: string;
- use?: string;
- };
- maxNcloc: number;
- planActiveUntil: string;
- }
-
- export interface CurrentUser {
- isLoggedIn: boolean;
- permissions?: { global: string[] };
- usingSonarLintConnectedMode?: boolean;
- }
-
- export interface CurrentUserSetting {
- key: CurrentUserSettingNames;
- value: string;
- }
-
- type CurrentUserSettingNames =
- | 'notifications.optOut'
- | 'notifications.readDate'
- | 'tutorials.jenkins.skipBitbucketPreReqs';
-
- export interface CustomMeasure {
- createdAt?: string;
- description?: string;
- id: string;
- metric: {
- key: string;
- name: string;
- domain?: string;
- type: string;
- };
- projectKey: string;
- pending?: boolean;
- user: T.UserBase;
- value: string;
- updatedAt?: string;
- }
-
- export interface Duplication {
- blocks: DuplicationBlock[];
- }
-
- export interface DuplicationBlock {
- _ref?: string;
- from: number;
- size: number;
- }
-
- export interface DuplicatedFile {
- key: string;
- name: string;
- project: string;
- projectName: string;
- subProject?: string;
- subProjectName?: string;
- }
-
- export type ExpandDirection = 'up' | 'down';
-
- export interface Extension {
- key: string;
- name: string;
- }
-
- export interface FacetValue<T = string> {
- count: number;
- val: T;
- }
-
- export interface FlowLocation {
- component: string;
- componentName?: string;
- index?: number;
- msg?: string;
- textRange: TextRange;
- }
-
- export interface Group {
- default?: boolean;
- description?: string;
- id: number;
- membersCount: number;
- name: string;
- }
-
- export type HealthType = 'RED' | 'YELLOW' | 'GREEN';
-
- export type HomePage =
- | { type: 'APPLICATION'; branch: string | undefined; component: string }
- | { type: 'ISSUES' }
- | { type: 'MY_ISSUES' }
- | { type: 'MY_PROJECTS' }
- | { type: 'PORTFOLIO'; component: string }
- | { type: 'PORTFOLIOS' }
- | { type: 'PROJECT'; branch: string | undefined; component: string }
- | { type: 'PROJECTS' };
-
- export type HomePageType =
- | 'APPLICATION'
- | 'ISSUES'
- | 'MY_ISSUES'
- | 'MY_PROJECTS'
- | 'PORTFOLIO'
- | 'PORTFOLIOS'
- | 'PROJECT'
- | 'PROJECTS';
-
- export interface IdentityProvider {
- backgroundColor: string;
- helpMessage?: string;
- iconPath: string;
- key: string;
- name: string;
- }
-
- export interface Issue {
- actions: string[];
- assignee?: string;
- assigneeActive?: boolean;
- assigneeAvatar?: string;
- assigneeLogin?: string;
- assigneeName?: string;
- author?: string;
- branch?: string;
- comments?: IssueComment[];
- component: string;
- componentLongName: string;
- componentQualifier: string;
- componentUuid: string;
- creationDate: string;
- effort?: string;
- externalRuleEngine?: string;
- fromExternalRule?: boolean;
- quickFixAvailable?: boolean;
- key: string;
- flows: FlowLocation[][];
- fromHotspot: boolean;
- line?: number;
- message: string;
- project: string;
- projectName: string;
- projectKey: string;
- pullRequest?: string;
- resolution?: string;
- rule: string;
- ruleName: string;
- ruleStatus?: string;
- secondaryLocations: FlowLocation[];
- severity: string;
- status: string;
- subProject?: string;
- subProjectName?: string;
- tags?: string[];
- textRange?: TextRange;
- transitions: string[];
- type: T.IssueType;
- }
-
- export interface IssueChangelog {
- avatar?: string;
- creationDate: string;
- diffs: IssueChangelogDiff[];
- user: string;
- isUserActive: boolean;
- userName: string;
- }
-
- export interface IssueChangelogDiff {
- key: string;
- newValue?: string;
- oldValue?: string;
- }
-
- export interface IssueComment {
- author?: string;
- authorActive?: boolean;
- authorAvatar?: string;
- authorLogin?: string;
- authorName?: string;
- createdAt: string;
- htmlText: string;
- key: string;
- markdown: string;
- updatable: boolean;
- }
-
- export interface IssuesByLine {
- [key: number]: Issue[];
- }
-
- export type IssueType = 'BUG' | 'VULNERABILITY' | 'CODE_SMELL' | 'SECURITY_HOTSPOT';
-
- export interface Language {
- key: string;
- name: string;
- }
-
- export type Languages = T.Dict<Language>;
-
- export interface LightComponent {
- key: string;
- qualifier: string;
- }
-
- export interface LinearIssueLocation {
- from: number;
- index?: number;
- line: number;
- startLine?: number;
- text?: string;
- to: number;
- }
-
- export interface LineMap {
- [line: number]: SourceLine;
- }
-
- export interface LinePopup {
- index?: number;
- line: number;
- name: string;
- open?: boolean;
- }
-
- export interface LoggedInUser extends CurrentUser, UserActive {
- externalIdentity?: string;
- externalProvider?: string;
- groups: string[];
- homepage?: HomePage;
- isLoggedIn: true;
- local?: boolean;
- scmAccounts: string[];
- settings?: CurrentUserSetting[];
- sonarLintAdSeen?: boolean;
- }
-
- export interface Measure extends MeasureIntern {
- metric: string;
- }
-
- export interface MeasureEnhanced extends MeasureIntern {
- metric: Metric;
- leak?: string;
- }
-
- interface MeasureIntern {
- bestValue?: boolean;
- period?: PeriodMeasure;
- value?: string;
- }
-
- export interface Metric {
- bestValue?: string;
- custom?: boolean;
- decimalScale?: number;
- description?: string;
- direction?: number;
- domain?: string;
- hidden?: boolean;
- higherValuesAreBetter?: boolean;
- id: string;
- key: string;
- name: string;
- qualitative?: boolean;
- type: string;
- worstValue?: string;
- }
-
- export interface MyProject {
- description?: string;
- key: string;
- lastAnalysisDate?: string;
- links: Array<{
- name: string;
- type: string;
- href: string;
- }>;
- name: string;
- qualityGate?: string;
- }
-
- export interface NewCodePeriod {
- type?: NewCodePeriodSettingType;
- value?: string;
- effectiveValue?: string;
- inherited?: boolean;
- }
-
- export interface NewCodePeriodBranch {
- projectKey: string;
- branchKey: string;
- inherited?: boolean;
- type?: NewCodePeriodSettingType;
- value?: string;
- effectiveValue?: string;
- }
-
- export type NewCodePeriodSettingType =
- | 'PREVIOUS_VERSION'
- | 'NUMBER_OF_DAYS'
- | 'SPECIFIC_ANALYSIS'
- | 'REFERENCE_BRANCH';
-
- export interface Notification {
- channel: string;
- project?: string;
- projectName?: string;
- type: string;
- }
-
- export interface NotificationProject {
- project: string;
- projectName: string;
- }
-
- export interface Paging {
- pageIndex: number;
- pageSize: number;
- total: number;
- }
-
- export interface Period {
- date: string;
- index?: number;
- mode: PeriodMode | NewCodePeriodSettingType;
- modeParam?: string;
- parameter?: string;
- }
-
- export interface PeriodMeasure {
- bestValue?: boolean;
- index: number;
- value: string;
- }
-
- /*
- * These are old baseline setting types, necessary for
- * backward compatibility.
- */
- export type PeriodMode =
- | 'days'
- | 'date'
- | 'version'
- | 'previous_analysis'
- | 'previous_version'
- | 'manual_baseline';
-
- export interface Permission {
- description: string;
- key: string;
- name: string;
- }
-
- export interface PermissionDefinition {
- key: string;
- name: string;
- description: string;
- }
-
- export type PermissionDefinitions = Array<PermissionDefinition | PermissionDefinitionGroup>;
-
- export interface PermissionDefinitionGroup {
- category: string;
- permissions: PermissionDefinition[];
- }
-
- export interface PermissionGroup {
- description?: string;
- id?: string;
- name: string;
- permissions: string[];
- }
-
- export interface PermissionUser extends UserActive {
- permissions: string[];
- }
-
- export interface PermissionTemplate {
- defaultFor: string[];
- id: string;
- name: string;
- description?: string;
- projectKeyPattern?: string;
- createdAt: string;
- updatedAt?: string;
- permissions: Array<{
- key: string;
- usersCount: number;
- groupsCount: number;
- withProjectCreator?: boolean;
- }>;
- }
-
- export interface ProfileInheritanceDetails {
- activeRuleCount: number;
- isBuiltIn: boolean;
- key: string;
- name: string;
- overridingRuleCount?: number;
- }
-
- export interface ProjectLink {
- id: string;
- name?: string;
- type: string;
- url: string;
- }
-
- export interface QualityGate {
- actions?: {
- associateProjects?: boolean;
- copy?: boolean;
- delegate?: boolean;
- delete?: boolean;
- manageConditions?: boolean;
- rename?: boolean;
- setAsDefault?: boolean;
- };
- conditions?: Condition[];
- id: string;
- isBuiltIn?: boolean;
- isDefault?: boolean;
- name: string;
- }
-
- export type RawQuery = T.Dict<any>;
-
- export interface Rule {
- isTemplate?: boolean;
- key: string;
- lang?: string;
- langName?: string;
- name: string;
- params?: RuleParameter[];
- severity: string;
- status: string;
- sysTags?: string[];
- tags?: string[];
- type: RuleType;
- }
-
- export interface RuleActivation {
- createdAt: string;
- inherit: RuleInheritance;
- params: { key: string; value: string }[];
- qProfile: string;
- severity: string;
- }
-
- export interface RuleDetails extends Rule {
- createdAt: string;
- debtOverloaded?: boolean;
- debtRemFnCoeff?: string;
- debtRemFnOffset?: string;
- debtRemFnType?: string;
- defaultDebtRemFnOffset?: string;
- defaultDebtRemFnType?: string;
- defaultRemFnBaseEffort?: string;
- defaultRemFnType?: string;
- effortToFixDescription?: string;
- htmlDesc?: string;
- htmlNote?: string;
- internalKey?: string;
- isExternal?: boolean;
- mdDesc?: string;
- mdNote?: string;
- remFnBaseEffort?: string;
- remFnOverloaded?: boolean;
- remFnType?: string;
- repo: string;
- scope?: RuleScope;
- templateKey?: string;
- }
-
- export type RuleInheritance = 'NONE' | 'INHERITED' | 'OVERRIDES';
-
- export interface RuleParameter {
- defaultValue?: string;
- htmlDesc?: string;
- key: string;
- type: string;
- }
-
- export type RuleScope = 'MAIN' | 'TEST' | 'ALL';
-
- export type RuleType = 'BUG' | 'VULNERABILITY' | 'CODE_SMELL' | 'SECURITY_HOTSPOT' | 'UNKNOWN';
-
- export interface Snippet {
- start: number;
- end: number;
- index: number;
- toDelete?: boolean;
- }
-
- export interface SnippetGroup extends SnippetsByComponent {
- locations: T.FlowLocation[];
- }
- export interface SnippetsByComponent {
- component: SourceViewerFile;
- sources: { [line: number]: SourceLine };
- }
-
- export interface SourceLine {
- code?: string;
- conditions?: number;
- coverageStatus?: SourceLineCoverageStatus;
- coveredConditions?: number;
- duplicated?: boolean;
- isNew?: boolean;
- line: number;
- lineHits?: number;
- scmAuthor?: string;
- scmDate?: string;
- scmRevision?: string;
- }
-
- export type SourceLineCoverageStatus = 'uncovered' | 'partially-covered' | 'covered';
-
- export interface SourceViewerFile {
- fav?: boolean;
- key: string;
- leakPeriodDate?: string;
- measures: {
- coverage?: string;
- duplicationDensity?: string;
- issues?: string;
- lines?: string;
- tests?: string;
- };
- path: string;
- project: string;
- projectName: string;
- q: string;
- subProject?: string;
- subProjectName?: string;
- uuid: string;
- }
-
- export type StandardSecurityCategories = T.Dict<{ title: string; description?: string }>;
-
- export type Status = 'ERROR' | 'OK';
-
- export interface SubscriptionPlan {
- maxNcloc: number;
- price: number;
- }
-
- export interface SuggestionLink {
- link: string;
- scope?: 'sonarcloud';
- text: string;
- }
-
- export interface SysInfoAppNode extends SysInfoBase {
- 'Compute Engine Logging': SysInfoLogging;
- Name: string;
- 'Web Logging': SysInfoLogging;
- }
-
- export interface SysInfoBase extends SysInfoValueObject {
- Health: HealthType;
- 'Health Causes': string[];
- Plugins?: Dict<string>;
- System: {
- Version: string;
- };
- }
-
- export interface SysInfoCluster extends SysInfoBase {
- 'Application Nodes': SysInfoAppNode[];
- 'Search Nodes': SysInfoSearchNode[];
- Settings: Dict<string>;
- Statistics?: {
- ncloc: number;
- };
- System: {
- 'High Availability': true;
- 'Server ID': string;
- Version: string;
- };
- }
-
- export interface SysInfoLogging extends Dict<string> {
- 'Logs Level': string;
- }
-
- export interface SysInfoSearchNode extends SysInfoValueObject {
- Name: string;
- }
-
- export interface SysInfoSection extends Dict<SysInfoValueObject> {}
-
- export interface SysInfoStandalone extends SysInfoBase {
- 'Compute Engine Logging': SysInfoLogging;
- Settings: Dict<string>;
- Statistics?: {
- ncloc: number;
- } & Dict<string | number>;
- System: {
- 'High Availability': false;
- 'Server ID': string;
- Version: string;
- };
- 'Web Logging': SysInfoLogging;
- }
-
- export type SysInfoValue =
- | boolean
- | string
- | number
- | undefined
- | HealthType
- | SysInfoValueObject
- | SysInfoValueArray;
-
- export interface SysInfoValueArray extends Array<SysInfoValue> {}
-
- export interface SysInfoValueObject extends Dict<SysInfoValue> {}
-
- export type SysStatus =
- | 'STARTING'
- | 'UP'
- | 'DOWN'
- | 'RESTARTING'
- | 'DB_MIGRATION_NEEDED'
- | 'DB_MIGRATION_RUNNING';
-
- export interface TestCase {
- coveredLines: number;
- durationInMs: number;
- fileId: string;
- fileKey: string;
- fileName: string;
- id: string;
- message?: string;
- name: string;
- stacktrace?: string;
- status: string;
- }
-
- export interface TextRange {
- startLine: number;
- startOffset: number;
- endLine: number;
- endOffset: number;
- }
-
- export interface User extends UserBase {
- externalIdentity?: string;
- externalProvider?: string;
- groups?: string[];
- lastConnectionDate?: string;
- local: boolean;
- scmAccounts?: string[];
- tokensCount?: number;
- }
-
- export interface UserActive extends UserBase {
- active?: true;
- name: string;
- }
-
- export interface UserBase {
- active?: boolean;
- avatar?: string;
- email?: string;
- login: string;
- name?: string;
- }
-
- export interface UserSelected extends UserActive {
- selected: boolean;
- }
-
- export interface UserToken {
- name: string;
- createdAt: string;
- lastConnectionDate?: string;
- }
-
- export interface NewUserToken extends UserToken {
- login: string;
- token: string;
- }
-
- export type Visibility = 'public' | 'private';
-
- export interface Webhook {
- key: string;
- latestDelivery?: WebhookDelivery;
- name: string;
- secret?: string;
- url: string;
- }
-
- export interface WebhookDelivery {
- at: string;
- durationMs: number;
- httpStatus?: number;
- id: string;
- success: boolean;
- }
-
- export namespace WebApi {
- export interface Action {
- key: string;
- changelog: Changelog[];
- description: string;
- deprecatedSince?: string;
- hasResponseExample: boolean;
- internal: boolean;
- params?: Param[];
- post: boolean;
- since?: string;
- }
-
- export interface Changelog {
- description: string;
- version: string;
- }
-
- export interface Domain {
- actions: Action[];
- deprecatedSince?: string;
- description: string;
- internal?: boolean;
- path: string;
- since?: string;
- }
-
- export interface Example {
- example: string;
- format: string;
- }
-
- export interface Param {
- defaultValue?: string;
- deprecatedKey?: string;
- deprecatedKeySince?: string;
- deprecatedSince?: string;
- description: string;
- exampleValue?: string;
- internal: boolean;
- key: string;
- maximumLength?: number;
- maximumValue?: number;
- maxValuesAllowed?: number;
- minimumLength?: number;
- minimumValue?: number;
- possibleValues?: string[];
- required: boolean;
- since?: string;
- }
- }
-}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2021 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+export type Dict<T> = { [key: string]: T };
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+
+export interface A11ySkipLink {
+ key: string;
+ label: string;
+ weight?: number;
+}
+
+export interface AlmApplication extends IdentityProvider {
+ installationUrl: string;
+}
+
+export interface AlmRepository {
+ label: string;
+ installationKey: string;
+ linkedProjectKey?: string;
+ linkedProjectName?: string;
+ private?: boolean;
+}
+
+export interface AlmUnboundApplication {
+ installationId: string;
+ key: string;
+ name: string;
+}
+
+interface BaseAnalysis {
+ buildString?: string;
+ detectedCI?: string;
+ events: AnalysisEvent[];
+ key: string;
+ manualNewCodePeriodBaseline?: boolean;
+ projectVersion?: string;
+}
+
+export interface Analysis extends BaseAnalysis {
+ date: string;
+}
+
+export interface ParsedAnalysis extends BaseAnalysis {
+ date: Date;
+}
+
+export interface AnalysisEvent {
+ category: string;
+ description?: string;
+ key: string;
+ name: string;
+ qualityGate?: {
+ failing: Array<{ branch: string; key: string; name: string }>;
+ status: string;
+ stillFailing: boolean;
+ };
+ definitionChange?: {
+ projects: Array<{
+ branch?: string;
+ changeType: string;
+ key: string;
+ name: string;
+ newBranch?: string;
+ oldBranch?: string;
+ }>;
+ };
+}
+
+export interface AppState {
+ adminPages?: Extension[];
+ authenticationError?: boolean;
+ authorizationError?: boolean;
+ branchesEnabled?: boolean;
+ canAdmin?: boolean;
+ edition: 'community' | 'developer' | 'enterprise' | 'datacenter' | undefined;
+ globalPages?: Extension[];
+ projectImportFeatureEnabled?: boolean;
+ instanceUsesDefaultAdminCredentials?: boolean;
+ multipleAlmEnabled?: boolean;
+ needIssueSync?: boolean;
+ productionDatabase: boolean;
+ qualifiers: string[];
+ settings: Dict<string>;
+ standalone?: boolean;
+ version: string;
+ webAnalyticsJsPath?: string;
+}
+
+export interface Breadcrumb {
+ key: string;
+ name: string;
+ qualifier: string;
+}
+
+export namespace Chart {
+ export interface Point {
+ x: Date;
+ y: number | string | undefined;
+ }
+
+ export interface Serie {
+ data: Point[];
+ name: string;
+ translatedName: string;
+ type: string;
+ }
+}
+
+export interface Component extends LightComponent {
+ alm?: { key: string; url: string };
+ analysisDate?: string;
+ breadcrumbs: Breadcrumb[];
+ canBrowseAllChildProjects?: boolean;
+ configuration?: ComponentConfiguration;
+ description?: string;
+ extensions?: Extension[];
+ isFavorite?: boolean;
+ leakPeriodDate?: string;
+ name: string;
+ needIssueSync?: boolean;
+ path?: string;
+ refKey?: string;
+ qualityProfiles?: ComponentQualityProfile[];
+ qualityGate?: { isDefault?: boolean; key: string; name: string };
+ tags?: string[];
+ version?: string;
+ visibility?: Visibility;
+}
+
+interface ComponentConfiguration {
+ canApplyPermissionTemplate?: boolean;
+ canBrowseProject?: boolean;
+ canUpdateProjectVisibilityToPrivate?: boolean;
+ extensions?: Extension[];
+ showBackgroundTasks?: boolean;
+ showHistory?: boolean;
+ showLinks?: boolean;
+ showQualityGates?: boolean;
+ showQualityProfiles?: boolean;
+ showPermissions?: boolean;
+ showSettings?: boolean;
+ showUpdateKey?: boolean;
+}
+
+export interface ComponentQualityProfile {
+ deleted?: boolean;
+ key: string;
+ language: string;
+ name: string;
+}
+
+export interface ComponentMeasureIntern {
+ branch?: string;
+ description?: string;
+ isFavorite?: boolean;
+ isRecentlyBrowsed?: boolean;
+ canBrowseAllChildProjects?: boolean;
+ key: string;
+ match?: string;
+ name: string;
+ path?: string;
+ project?: string;
+ qualifier: string;
+ refKey?: string;
+}
+
+export interface ComponentMeasure extends ComponentMeasureIntern {
+ measures?: Measure[];
+}
+
+export interface ComponentMeasureEnhanced extends ComponentMeasureIntern {
+ value?: string;
+ leak?: string;
+ measures: MeasureEnhanced[];
+}
+
+export interface Condition {
+ error: string;
+ id: number;
+ metric: string;
+ op?: string;
+}
+
+export interface CoveredFile {
+ key: string;
+ longName: string;
+ coveredLines: number;
+}
+
+export interface Coupon {
+ billing?: {
+ address?: string;
+ country?: string;
+ email?: string;
+ name?: string;
+ use?: string;
+ };
+ maxNcloc: number;
+ planActiveUntil: string;
+}
+
+export interface CurrentUser {
+ isLoggedIn: boolean;
+ permissions?: { global: string[] };
+ usingSonarLintConnectedMode?: boolean;
+}
+
+export interface CurrentUserSetting {
+ key: CurrentUserSettingNames;
+ value: string;
+}
+
+export type CurrentUserSettingNames =
+ | 'notifications.optOut'
+ | 'notifications.readDate'
+ | 'tutorials.jenkins.skipBitbucketPreReqs';
+
+export interface CustomMeasure {
+ createdAt?: string;
+ description?: string;
+ id: string;
+ metric: {
+ key: string;
+ name: string;
+ domain?: string;
+ type: string;
+ };
+ projectKey: string;
+ pending?: boolean;
+ user: UserBase;
+ value: string;
+ updatedAt?: string;
+}
+
+export interface Duplication {
+ blocks: DuplicationBlock[];
+}
+
+export interface DuplicationBlock {
+ _ref?: string;
+ from: number;
+ size: number;
+}
+
+export interface DuplicatedFile {
+ key: string;
+ name: string;
+ project: string;
+ projectName: string;
+ subProject?: string;
+ subProjectName?: string;
+}
+
+export type ExpandDirection = 'up' | 'down';
+
+export interface Extension {
+ key: string;
+ name: string;
+}
+
+export interface FacetValue<T = string> {
+ count: number;
+ val: T;
+}
+
+export interface FlowLocation {
+ component: string;
+ componentName?: string;
+ index?: number;
+ msg?: string;
+ textRange: TextRange;
+}
+
+export interface Group {
+ default?: boolean;
+ description?: string;
+ id: number;
+ membersCount: number;
+ name: string;
+}
+
+export type HealthType = 'RED' | 'YELLOW' | 'GREEN';
+
+export type HomePage =
+ | { type: 'APPLICATION'; branch: string | undefined; component: string }
+ | { type: 'ISSUES' }
+ | { type: 'MY_ISSUES' }
+ | { type: 'MY_PROJECTS' }
+ | { type: 'PORTFOLIO'; component: string }
+ | { type: 'PORTFOLIOS' }
+ | { type: 'PROJECT'; branch: string | undefined; component: string }
+ | { type: 'PROJECTS' };
+
+export type HomePageType =
+ | 'APPLICATION'
+ | 'ISSUES'
+ | 'MY_ISSUES'
+ | 'MY_PROJECTS'
+ | 'PORTFOLIO'
+ | 'PORTFOLIOS'
+ | 'PROJECT'
+ | 'PROJECTS';
+
+export interface IdentityProvider {
+ backgroundColor: string;
+ helpMessage?: string;
+ iconPath: string;
+ key: string;
+ name: string;
+}
+
+export interface Issue {
+ actions: string[];
+ assignee?: string;
+ assigneeActive?: boolean;
+ assigneeAvatar?: string;
+ assigneeLogin?: string;
+ assigneeName?: string;
+ author?: string;
+ branch?: string;
+ comments?: IssueComment[];
+ component: string;
+ componentLongName: string;
+ componentQualifier: string;
+ componentUuid: string;
+ creationDate: string;
+ effort?: string;
+ externalRuleEngine?: string;
+ fromExternalRule?: boolean;
+ quickFixAvailable?: boolean;
+ key: string;
+ flows: FlowLocation[][];
+ fromHotspot: boolean;
+ line?: number;
+ message: string;
+ project: string;
+ projectName: string;
+ projectKey: string;
+ pullRequest?: string;
+ resolution?: string;
+ rule: string;
+ ruleName: string;
+ ruleStatus?: string;
+ secondaryLocations: FlowLocation[];
+ severity: string;
+ status: string;
+ subProject?: string;
+ subProjectName?: string;
+ tags?: string[];
+ textRange?: TextRange;
+ transitions: string[];
+ type: IssueType;
+}
+
+export interface IssueChangelog {
+ avatar?: string;
+ creationDate: string;
+ diffs: IssueChangelogDiff[];
+ user: string;
+ isUserActive: boolean;
+ userName: string;
+}
+
+export interface IssueChangelogDiff {
+ key: string;
+ newValue?: string;
+ oldValue?: string;
+}
+
+export interface IssueComment {
+ author?: string;
+ authorActive?: boolean;
+ authorAvatar?: string;
+ authorLogin?: string;
+ authorName?: string;
+ createdAt: string;
+ htmlText: string;
+ key: string;
+ markdown: string;
+ updatable: boolean;
+}
+
+export interface IssuesByLine {
+ [key: number]: Issue[];
+}
+
+export type IssueType = 'BUG' | 'VULNERABILITY' | 'CODE_SMELL' | 'SECURITY_HOTSPOT';
+
+export interface Language {
+ key: string;
+ name: string;
+}
+
+export type Languages = Dict<Language>;
+
+export interface LightComponent {
+ key: string;
+ qualifier: string;
+}
+
+export interface LinearIssueLocation {
+ from: number;
+ index?: number;
+ line: number;
+ startLine?: number;
+ text?: string;
+ to: number;
+}
+
+export interface LineMap {
+ [line: number]: SourceLine;
+}
+
+export interface LinePopup {
+ index?: number;
+ line: number;
+ name: string;
+ open?: boolean;
+}
+
+export interface LoggedInUser extends CurrentUser, UserActive {
+ externalIdentity?: string;
+ externalProvider?: string;
+ groups: string[];
+ homepage?: HomePage;
+ isLoggedIn: true;
+ local?: boolean;
+ scmAccounts: string[];
+ settings?: CurrentUserSetting[];
+ sonarLintAdSeen?: boolean;
+}
+
+export interface Measure extends MeasureIntern {
+ metric: string;
+}
+
+export interface MeasureEnhanced extends MeasureIntern {
+ metric: Metric;
+ leak?: string;
+}
+
+export interface MeasureIntern {
+ bestValue?: boolean;
+ period?: PeriodMeasure;
+ value?: string;
+}
+
+export interface Metric {
+ bestValue?: string;
+ custom?: boolean;
+ decimalScale?: number;
+ description?: string;
+ direction?: number;
+ domain?: string;
+ hidden?: boolean;
+ higherValuesAreBetter?: boolean;
+ id: string;
+ key: string;
+ name: string;
+ qualitative?: boolean;
+ type: string;
+ worstValue?: string;
+}
+
+export interface MyProject {
+ description?: string;
+ key: string;
+ lastAnalysisDate?: string;
+ links: Array<{
+ name: string;
+ type: string;
+ href: string;
+ }>;
+ name: string;
+ qualityGate?: string;
+}
+
+export interface NewCodePeriod {
+ type?: NewCodePeriodSettingType;
+ value?: string;
+ effectiveValue?: string;
+ inherited?: boolean;
+}
+
+export interface NewCodePeriodBranch {
+ projectKey: string;
+ branchKey: string;
+ inherited?: boolean;
+ type?: NewCodePeriodSettingType;
+ value?: string;
+ effectiveValue?: string;
+}
+
+export type NewCodePeriodSettingType =
+ | 'PREVIOUS_VERSION'
+ | 'NUMBER_OF_DAYS'
+ | 'SPECIFIC_ANALYSIS'
+ | 'REFERENCE_BRANCH';
+
+export interface Notification {
+ channel: string;
+ project?: string;
+ projectName?: string;
+ type: string;
+}
+
+export interface NotificationProject {
+ project: string;
+ projectName: string;
+}
+
+export interface Paging {
+ pageIndex: number;
+ pageSize: number;
+ total: number;
+}
+
+export interface Period {
+ date: string;
+ index?: number;
+ mode: PeriodMode | NewCodePeriodSettingType;
+ modeParam?: string;
+ parameter?: string;
+}
+
+export interface PeriodMeasure {
+ bestValue?: boolean;
+ index: number;
+ value: string;
+}
+
+/*
+ * These are old baseline setting types, necessary for
+ * backward compatibility.
+ */
+export type PeriodMode =
+ | 'days'
+ | 'date'
+ | 'version'
+ | 'previous_analysis'
+ | 'previous_version'
+ | 'manual_baseline';
+
+export interface Permission {
+ description: string;
+ key: string;
+ name: string;
+}
+
+export interface PermissionDefinition {
+ key: string;
+ name: string;
+ description: string;
+}
+
+export type PermissionDefinitions = Array<PermissionDefinition | PermissionDefinitionGroup>;
+
+export interface PermissionDefinitionGroup {
+ category: string;
+ permissions: PermissionDefinition[];
+}
+
+export interface PermissionGroup {
+ description?: string;
+ id?: string;
+ name: string;
+ permissions: string[];
+}
+
+export interface PermissionUser extends UserActive {
+ permissions: string[];
+}
+
+export interface PermissionTemplate {
+ defaultFor: string[];
+ id: string;
+ name: string;
+ description?: string;
+ projectKeyPattern?: string;
+ createdAt: string;
+ updatedAt?: string;
+ permissions: Array<{
+ key: string;
+ usersCount: number;
+ groupsCount: number;
+ withProjectCreator?: boolean;
+ }>;
+}
+
+export interface ProfileInheritanceDetails {
+ activeRuleCount: number;
+ isBuiltIn: boolean;
+ key: string;
+ name: string;
+ overridingRuleCount?: number;
+}
+
+export interface ProjectLink {
+ id: string;
+ name?: string;
+ type: string;
+ url: string;
+}
+
+export interface QualityGate {
+ actions?: {
+ associateProjects?: boolean;
+ copy?: boolean;
+ delegate?: boolean;
+ delete?: boolean;
+ manageConditions?: boolean;
+ rename?: boolean;
+ setAsDefault?: boolean;
+ };
+ conditions?: Condition[];
+ id: string;
+ isBuiltIn?: boolean;
+ isDefault?: boolean;
+ name: string;
+}
+
+export type RawQuery = Dict<any>;
+
+export interface Rule {
+ isTemplate?: boolean;
+ key: string;
+ lang?: string;
+ langName?: string;
+ name: string;
+ params?: RuleParameter[];
+ severity: string;
+ status: string;
+ sysTags?: string[];
+ tags?: string[];
+ type: RuleType;
+}
+
+export interface RuleActivation {
+ createdAt: string;
+ inherit: RuleInheritance;
+ params: { key: string; value: string }[];
+ qProfile: string;
+ severity: string;
+}
+
+export interface RuleDetails extends Rule {
+ createdAt: string;
+ debtOverloaded?: boolean;
+ debtRemFnCoeff?: string;
+ debtRemFnOffset?: string;
+ debtRemFnType?: string;
+ defaultDebtRemFnOffset?: string;
+ defaultDebtRemFnType?: string;
+ defaultRemFnBaseEffort?: string;
+ defaultRemFnType?: string;
+ effortToFixDescription?: string;
+ htmlDesc?: string;
+ htmlNote?: string;
+ internalKey?: string;
+ isExternal?: boolean;
+ mdDesc?: string;
+ mdNote?: string;
+ remFnBaseEffort?: string;
+ remFnOverloaded?: boolean;
+ remFnType?: string;
+ repo: string;
+ scope?: RuleScope;
+ templateKey?: string;
+}
+
+export type RuleInheritance = 'NONE' | 'INHERITED' | 'OVERRIDES';
+
+export interface RuleParameter {
+ defaultValue?: string;
+ htmlDesc?: string;
+ key: string;
+ type: string;
+}
+
+export type RuleScope = 'MAIN' | 'TEST' | 'ALL';
+
+export type RuleType = 'BUG' | 'VULNERABILITY' | 'CODE_SMELL' | 'SECURITY_HOTSPOT' | 'UNKNOWN';
+
+export interface Snippet {
+ start: number;
+ end: number;
+ index: number;
+ toDelete?: boolean;
+}
+
+export interface SnippetGroup extends SnippetsByComponent {
+ locations: FlowLocation[];
+}
+export interface SnippetsByComponent {
+ component: SourceViewerFile;
+ sources: { [line: number]: SourceLine };
+}
+
+export interface SourceLine {
+ code?: string;
+ conditions?: number;
+ coverageStatus?: SourceLineCoverageStatus;
+ coveredConditions?: number;
+ duplicated?: boolean;
+ isNew?: boolean;
+ line: number;
+ lineHits?: number;
+ scmAuthor?: string;
+ scmDate?: string;
+ scmRevision?: string;
+}
+
+export type SourceLineCoverageStatus = 'uncovered' | 'partially-covered' | 'covered';
+
+export interface SourceViewerFile {
+ fav?: boolean;
+ key: string;
+ leakPeriodDate?: string;
+ measures: {
+ coverage?: string;
+ duplicationDensity?: string;
+ issues?: string;
+ lines?: string;
+ tests?: string;
+ };
+ path: string;
+ project: string;
+ projectName: string;
+ q: string;
+ subProject?: string;
+ subProjectName?: string;
+ uuid: string;
+}
+
+export type StandardSecurityCategories = Dict<{ title: string; description?: string }>;
+
+export type Status = 'ERROR' | 'OK';
+
+export interface SubscriptionPlan {
+ maxNcloc: number;
+ price: number;
+}
+
+export interface SuggestionLink {
+ link: string;
+ scope?: 'sonarcloud';
+ text: string;
+}
+
+export interface SysInfoAppNode extends SysInfoBase {
+ 'Compute Engine Logging': SysInfoLogging;
+ Name: string;
+ 'Web Logging': SysInfoLogging;
+}
+
+export interface SysInfoBase extends SysInfoValueObject {
+ Health: HealthType;
+ 'Health Causes': string[];
+ Plugins?: Dict<string>;
+ System: {
+ Version: string;
+ };
+}
+
+export interface SysInfoCluster extends SysInfoBase {
+ 'Application Nodes': SysInfoAppNode[];
+ 'Search Nodes': SysInfoSearchNode[];
+ Settings: Dict<string>;
+ Statistics?: {
+ ncloc: number;
+ };
+ System: {
+ 'High Availability': true;
+ 'Server ID': string;
+ Version: string;
+ };
+}
+
+export interface SysInfoLogging extends Dict<string> {
+ 'Logs Level': string;
+}
+
+export interface SysInfoSearchNode extends SysInfoValueObject {
+ Name: string;
+}
+
+export interface SysInfoSection extends Dict<SysInfoValueObject> {}
+
+export interface SysInfoStandalone extends SysInfoBase {
+ 'Compute Engine Logging': SysInfoLogging;
+ Settings: Dict<string>;
+ Statistics?: {
+ ncloc: number;
+ } & Dict<string | number>;
+ System: {
+ 'High Availability': false;
+ 'Server ID': string;
+ Version: string;
+ };
+ 'Web Logging': SysInfoLogging;
+}
+
+export type SysInfoValue =
+ | boolean
+ | string
+ | number
+ | undefined
+ | HealthType
+ | SysInfoValueObject
+ | SysInfoValueArray;
+
+export interface SysInfoValueArray extends Array<SysInfoValue> {}
+
+export interface SysInfoValueObject extends Dict<SysInfoValue> {}
+
+export type SysStatus =
+ | 'STARTING'
+ | 'UP'
+ | 'DOWN'
+ | 'RESTARTING'
+ | 'DB_MIGRATION_NEEDED'
+ | 'DB_MIGRATION_RUNNING';
+
+export interface TestCase {
+ coveredLines: number;
+ durationInMs: number;
+ fileId: string;
+ fileKey: string;
+ fileName: string;
+ id: string;
+ message?: string;
+ name: string;
+ stacktrace?: string;
+ status: string;
+}
+
+export interface TextRange {
+ startLine: number;
+ startOffset: number;
+ endLine: number;
+ endOffset: number;
+}
+
+export interface User extends UserBase {
+ externalIdentity?: string;
+ externalProvider?: string;
+ groups?: string[];
+ lastConnectionDate?: string;
+ local: boolean;
+ scmAccounts?: string[];
+ tokensCount?: number;
+}
+
+export interface UserActive extends UserBase {
+ active?: true;
+ name: string;
+}
+
+export interface UserBase {
+ active?: boolean;
+ avatar?: string;
+ email?: string;
+ login: string;
+ name?: string;
+}
+
+export interface UserSelected extends UserActive {
+ selected: boolean;
+}
+
+export interface UserToken {
+ name: string;
+ createdAt: string;
+ lastConnectionDate?: string;
+}
+
+export interface NewUserToken extends UserToken {
+ login: string;
+ token: string;
+}
+
+export type Visibility = 'public' | 'private';
+
+export interface Webhook {
+ key: string;
+ latestDelivery?: WebhookDelivery;
+ name: string;
+ secret?: string;
+ url: string;
+}
+
+export interface WebhookDelivery {
+ at: string;
+ durationMs: number;
+ httpStatus?: number;
+ id: string;
+ success: boolean;
+}
+
+export namespace WebApi {
+ export interface Action {
+ key: string;
+ changelog: Changelog[];
+ description: string;
+ deprecatedSince?: string;
+ hasResponseExample: boolean;
+ internal: boolean;
+ params?: Param[];
+ post: boolean;
+ since?: string;
+ }
+
+ export interface Changelog {
+ description: string;
+ version: string;
+ }
+
+ export interface Domain {
+ actions: Action[];
+ deprecatedSince?: string;
+ description: string;
+ internal?: boolean;
+ path: string;
+ since?: string;
+ }
+
+ export interface Example {
+ example: string;
+ format: string;
+ }
+
+ export interface Param {
+ defaultValue?: string;
+ deprecatedKey?: string;
+ deprecatedKeySince?: string;
+ deprecatedSince?: string;
+ description: string;
+ exampleValue?: string;
+ internal: boolean;
+ key: string;
+ maximumLength?: number;
+ maximumValue?: number;
+ maxValuesAllowed?: number;
+ minimumLength?: number;
+ minimumValue?: number;
+ possibleValues?: string[];
+ required: boolean;
+ since?: string;
+ }
+}
projects / sonarqube.git / commitdiff