@truedat/dq 4.43.6 → 4.44.2

package/src/components/NewRuleImplementation.js

@@ -2,7 +2,7 @@ import _ from "lodash/fp";
 import React, { useState, useEffect } from "react";
 import PropTypes from "prop-types";
 import { connect } from "react-redux";
-import { Button, Divider, Header, Grid } from "semantic-ui-react";
+import { Divider, Header, Grid } from "semantic-ui-react";
 import { FormattedMessage } from "react-intl";
 import { gql, useQuery } from "@apollo/client";
 import { Loading } from "@truedat/core/components";
@@ -237,7 +237,6 @@ const withConditionDefaultAlias = (conditions, structures) =>
   })(conditions);
 
 export const NewRuleImplementation = ({
-  canManageRaw,
   clone,
   createRuleImplementation,
   updateRuleImplementation,
@@ -251,6 +250,7 @@ export const NewRuleImplementation = ({
   operators,
   template,
   applyTemplate,
+  implementationType = "",
 }) => {
   const precalculatedDataset = _.flow(
     _.propOr([{}], "dataset"),
@@ -316,11 +316,13 @@ export const NewRuleImplementation = ({
           result_type: ruleImplementationProps.result_type,
           minimum: ruleImplementationProps.minimum,
           goal: ruleImplementationProps.goal,
+          rule_id: ruleImplementationProps.rule_id,
+          domain_id: ruleImplementationProps.domain_id,
         }
       : {
           executable: true,
           implementationKey: "",
-          implementationType: "default",
+          implementationType,
           dataset: [{}],
           population: [],
           populations: [],
@@ -460,9 +462,6 @@ export const NewRuleImplementation = ({
   const setImplementationKey = (implementationKey) =>
     setRuleImplementation({ ...ruleImplementation, implementationKey });
 
-  const setImplementationType = (implementationType) =>
-    setRuleImplementation({ ...ruleImplementation, implementationType });
-
   const setImplementationRawContent = (rawContent) =>
     setRuleImplementation({ ...ruleImplementation, rawContent });
 
@@ -502,11 +501,12 @@ export const NewRuleImplementation = ({
               _.prop("implementationType")(ruleImplementation),
             df_name,
             df_content: dfContent,
-            rule_id: rule.id,
+            rule_id: rule ? rule.id : ruleImplementation.rule_id,
             raw_content: { ...raw_content, source },
             result_type: ruleImplementation.result_type,
             minimum: ruleImplementation.minimum,
             goal: ruleImplementation.goal,
+            domain_id: ruleImplementation.domain_id,
           }
         : {
             executable: ruleImplementation.executable,
@@ -519,10 +519,11 @@ export const NewRuleImplementation = ({
               _.prop("implementationType")(ruleImplementation),
             df_name,
             df_content: dfContent,
-            rule_id: rule.id,
+            rule_id: rule ? rule.id : ruleImplementation.rule_id,
             result_type: ruleImplementation.result_type,
             minimum: ruleImplementation.minimum,
             goal: ruleImplementation.goal,
+            domain_id: ruleImplementation.domain_id,
           };
 
     clone || !edition
@@ -543,20 +544,6 @@ export const NewRuleImplementation = ({
       <Grid divided className="full-height">
         <Grid.Column width="11">
           <Grid.Row>
-            {!edition && canManageRaw && (
-              <Button.Group floated="right">
-                <Button
-                  active={ruleImplementation.implementationType != "raw"}
-                  icon="tasks"
-                  onClick={() => setImplementationType("")}
-                />
-                <Button
-                  active={ruleImplementation.implementationType == "raw"}
-                  icon="file alternate outline"
-                  onClick={() => setImplementationType("raw")}
-                />
-              </Button.Group>
-            )}
             <Header as="h2">
               <Header.Content>
                 <FormattedMessage
@@ -616,7 +603,6 @@ export const NewRuleImplementation = ({
 };
 
 NewRuleImplementation.propTypes = {
-  canManageRaw: PropTypes.bool,
   clone: PropTypes.bool,
   createRuleImplementation: PropTypes.func.isRequired,
   updateRuleImplementation: PropTypes.func,
@@ -630,6 +616,7 @@ NewRuleImplementation.propTypes = {
   applyTemplate: PropTypes.func,
   sources: PropTypes.array,
   sourcesLoading: PropTypes.bool,
+  implementationType: PropTypes.string,
 };
 
 export const SOURCES_WITH_CONFIG = gql`
@@ -643,7 +630,7 @@ export const SOURCES_WITH_CONFIG = gql`
 `;
 
 export const NewRuleImplementationLoader = (props) => {
-  const { data, error, loading } = useQuery(SOURCES_WITH_CONFIG, {
+  const { data, loading } = useQuery(SOURCES_WITH_CONFIG, {
     variables: { jobTypes: "quality" },
   });
   if (loading) return <Loading />;
@@ -666,9 +653,6 @@ const mapStateToProps = (state) => ({
   ruleImplementationRaw: state.ruleImplementationRaw,
   structuresFields: state.structuresFields,
   structuresSiblings: state.structuresSiblings,
-  canManageRaw: _.prop("manage_raw_quality_rule_implementations")(
-    state.userRulePermissions
-  ),
   operators: getRuleImplementationOperators(state),
   template: _.defaultTo({})(state.template),
   applyTemplate: applyTemplate(state.template),

package/src/components/RemediationCrumbs.js

@@ -37,8 +37,7 @@ export const RemediationCrumbs = ({ rule, ruleImplementation }) => {
           {ruleResultId ? (
             <Breadcrumb.Section
               as={Link}
-              to={linkTo.RULE_IMPLEMENTATION({
-                id: rule.id,
+              to={linkTo.IMPLEMENTATION({
                 implementation_id: ruleImplementation.id,
               })}
               active={_.isEmpty(ruleImplementation)}

package/src/components/RuleCrumbs.js

@@ -1,83 +1,26 @@
-import _ from "lodash/fp";
 import React from "react";
 import PropTypes from "prop-types";
 import { Breadcrumb } from "semantic-ui-react";
 import { connect } from "react-redux";
-import { Link, useParams } from "react-router-dom";
+import { Link } from "react-router-dom";
 import { FormattedMessage } from "react-intl";
-import { RULES, linkTo } from "@truedat/core/routes";
-import { DateTime } from "@truedat/core/components";
-
-export const RuleCrumbs = ({ rule, ruleImplementation }) => {
-  const { rule_result_id } = useParams();
-
-  const ruleResultDate = _.flow(
-    _.propOr([], "results"),
-    _.find(_.propEq("id", _.toNumber(rule_result_id))),
-    _.pathOr("0000-00-00 00:00", "date")
-  )(ruleImplementation);
+import { RULES } from "@truedat/core/routes";
 
+export const RuleCrumbs = ({ rule }) => {
   return rule.name ? (
     <Breadcrumb>
       <Breadcrumb.Section as={Link} to={RULES} active={false}>
         <FormattedMessage id="rules.crumbs.top" />
       </Breadcrumb.Section>
-      {rule.name && (
-        <>
-          <Breadcrumb.Divider icon="right angle" />
-          {ruleImplementation.id ? (
-            <Breadcrumb.Section
-              as={Link}
-              to={linkTo.RULE({ id: rule.id })}
-              active={_.isEmpty(ruleImplementation)}
-            >
-              {rule.name}
-            </Breadcrumb.Section>
-          ) : (
-            <Breadcrumb.Section active>{rule.name}</Breadcrumb.Section>
-          )}
-        </>
-      )}
-      {ruleImplementation.id && (
-        <>
-          <Breadcrumb.Divider icon="right angle" />
-          {rule_result_id ? (
-            <Breadcrumb.Section
-              as={Link}
-              to={linkTo.RULE_IMPLEMENTATION({
-                id: rule.id,
-                implementation_id: ruleImplementation.id,
-              })}
-              active={_.isEmpty(ruleImplementation)}
-            >
-              {ruleImplementation.implementation_key}
-            </Breadcrumb.Section>
-          ) : (
-            <Breadcrumb.Section active>
-              {ruleImplementation.implementation_key}
-            </Breadcrumb.Section>
-          )}
-        </>
-      )}
-      {rule_result_id && (
-        <>
-          <Breadcrumb.Divider icon="right angle" />
-          <Breadcrumb.Section active>
-            {<DateTime value={ruleResultDate} />}
-          </Breadcrumb.Section>
-        </>
-      )}
+      <Breadcrumb.Divider icon="right angle" />
+      <Breadcrumb.Section active>{rule.name}</Breadcrumb.Section>
     </Breadcrumb>
   ) : null;
 };
 
 RuleCrumbs.propTypes = {
   rule: PropTypes.object,
-  ruleImplementation: PropTypes.object,
 };
 
-const mapStateToProps = ({ rule, ruleImplementation }) => ({
-  rule,
-  ruleImplementation,
-});
+const mapStateToProps = ({ rule }) => ({ rule });
 export default connect(mapStateToProps)(RuleCrumbs);

package/src/components/RuleImplementation.js

@@ -70,13 +70,10 @@ const getAvailableActions = (props, formatMessage) => {
           text: formatMessage({ id: "ruleImplementation.actions.edit" }),
           value: "edit",
           as: Link,
-          to: linkTo.RULE_IMPLEMENTATION_EDIT({
-            id: _.path("rule.id")(props),
+          to: linkTo.IMPLEMENTATION_EDIT({
             implementation_id: _.path("ruleImplementation.id")(props),
           }),
-          filter:
-            props.authManageSegments ||
-            _.isEmpty(props.ruleImplementation.segments),
+          filter: props.editPermission,
           selected: false,
           active: false,
         },
@@ -86,8 +83,7 @@ const getAvailableActions = (props, formatMessage) => {
           text: formatMessage({ id: "ruleImplementation.actions.move" }),
           value: "move",
           as: Link,
-          to: linkTo.RULE_IMPLEMENTATION_MOVE({
-            id: _.path("rule.id")(props),
+          to: linkTo.IMPLEMENTATION_MOVE({
             implementation_id: _.path("ruleImplementation.id")(props),
           }),
           filter: props?.authorized,
@@ -100,8 +96,7 @@ const getAvailableActions = (props, formatMessage) => {
           text: formatMessage({ id: "ruleImplementation.actions.clone" }),
           value: "clone",
           as: Link,
-          to: linkTo.RULE_IMPLEMENTATION_CLONE({
-            id: _.path("rule.id")(props),
+          to: linkTo.IMPLEMENTATION_CLONE({
             implementation_id: _.path("ruleImplementation.id")(props),
           }),
           filter: true,
@@ -121,7 +116,6 @@ const OptionModal = ({
   iconName,
   option,
   restore,
-  rule,
   ruleImplementation,
   setRuleImplementationStatus,
 }) => {
@@ -139,7 +133,6 @@ const OptionModal = ({
       content={formatMessage({ id: contentMessage })}
       onConfirm={() =>
         setRuleImplementationStatus({
-          ruleId: rule.id,
           id: ruleImplementation.id,
           ...payload,
         })
@@ -158,7 +151,6 @@ OptionModal.propTypes = {
   iconName: PropTypes.string,
   option: PropTypes.string,
   restore: PropTypes.bool,
-  rule: PropTypes.object,
   ruleImplementation: PropTypes.object,
   setRuleImplementationStatus: PropTypes.func,
 };
@@ -166,10 +158,9 @@ OptionModal.propTypes = {
 export const RuleImplementation = ({
   children,
   setRuleImplementationStatus,
-  rule,
   ruleImplementation,
-  userRulePermissions,
-  authManageSegments,
+  editPermission,
+  managePermission,
 }) => {
   const authorized = useAuthorized();
   const { formatMessage } = useIntl();
@@ -179,10 +170,9 @@ export const RuleImplementation = ({
     {
       activeMode,
       authorized,
-      rule,
       ruleImplementation,
       setRuleImplementationStatus,
-      authManageSegments,
+      editPermission,
     },
     formatMessage
   );
@@ -209,12 +199,9 @@ export const RuleImplementation = ({
                 icon={{ name: "warning circle", color: "red" }}
               />
             )}
-            {_.prop("manage_quality_rule_implementations")(
-              userRulePermissions
-            ) &&
-              !_.isEmpty(availableActions) && (
-                <GroupActions availableActions={availableActions} />
-              )}
+            {managePermission && !_.isEmpty(availableActions) && (
+              <GroupActions availableActions={availableActions} />
+            )}
           </>
         </Grid.Column>
       </Grid>
@@ -227,24 +214,16 @@ export const RuleImplementation = ({
 RuleImplementation.propTypes = {
   ruleImplementation: PropTypes.object.isRequired,
   setRuleImplementationStatus: PropTypes.func,
-  rule: PropTypes.object,
   ruleImplementation: PropTypes.object,
-  userRulePermissions: PropTypes.object,
-  authManageSegments: PropTypes.bool,
+  editPermission: PropTypes.bool,
+  managePermission: PropTypes.bool,
   children: PropTypes.node,
 };
 
-const mapStateToProps = ({
-  rule,
-  ruleImplementation,
-  userRulePermissions,
-  implementationActions,
-}) => ({
-  rule,
+const mapStateToProps = ({ ruleImplementation, implementationActions }) => ({
   ruleImplementation,
-  userRulePermissions,
-  authManageSegments:
-    _.pathOr(false, "manage_segments.method")(implementationActions) === "POST",
+  editPermission: !!_.pathOr(false, "edit")(implementationActions),
+  managePermission: !!_.pathOr(false, "manage")(implementationActions),
 });
 
 export default connect(mapStateToProps, { setRuleImplementationStatus })(

package/src/components/RuleImplementationActions.js

@@ -7,23 +7,26 @@ import { Link, useParams } from "react-router-dom";
 import { Button } from "semantic-ui-react";
 import { linkTo } from "@truedat/core/routes";
 
-const createRuleImplementationUrl = linkTo.RULE_IMPLEMENTATION_NEW;
-
-const getCreateRuleImplementationUrl = ({ id }) =>
-  createRuleImplementationUrl({ id });
-
 const RuleImplementationActions = ({
   manageRuleImplementationAction,
-  rule: { id }
+  manageRawRuleImplementationAction,
 }) => {
   const params = useParams();
   return (
     <>
+      {manageRawRuleImplementationAction && (
+        <Button
+          as={Link}
+          to={linkTo.RULE_IMPLEMENTATION_NEW_RAW(params)}
+          className="primary_action"
+          content={<FormattedMessage id="quality.rule.actions.create_raw" />}
+        />
+      )}
       {manageRuleImplementationAction && (
         <Button
           primary
           as={Link}
-          to={getCreateRuleImplementationUrl(params, id)}
+          to={linkTo.RULE_IMPLEMENTATION_NEW(params)}
           className="primary_action"
           content={<FormattedMessage id="quality.rule.actions.create" />}
         />
@@ -33,17 +36,20 @@ const RuleImplementationActions = ({
 };
 
 RuleImplementationActions.propTypes = {
-  rule: PropTypes.object.isRequired,
-  manageRuleImplementationAction: PropTypes.bool
+  manageRuleImplementationAction: PropTypes.bool,
+  manageRawRuleImplementationAction: PropTypes.bool,
 };
 
-const mapStateToProps = ({ rule, userRulePermissions }) => ({
-  rule,
+const mapStateToProps = ({ userRulePermissions }) => ({
   userRulePermissions: userRulePermissions,
   manageRuleImplementationAction: _.propOr(
     false,
     "manage_quality_rule_implementations"
-  )(userRulePermissions)
+  )(userRulePermissions),
+  manageRawRuleImplementationAction: _.propOr(
+    false,
+    "manage_raw_quality_rule_implementations"
+  )(userRulePermissions),
 });
 
 export default connect(mapStateToProps)(RuleImplementationActions);

package/src/components/RuleImplementationLink.js

@@ -3,8 +3,8 @@ import PropTypes from "prop-types";
 import { Link } from "react-router-dom";
 import { linkTo } from "@truedat/core/routes";
 
-export const RuleImplementationLink = ({ id, implementation_key, rule_id }) => (
-  <Link to={linkTo.RULE_IMPLEMENTATION({ id: rule_id, implementation_id: id })}>
+export const RuleImplementationLink = ({ id, implementation_key }) => (
+  <Link to={linkTo.IMPLEMENTATION({ implementation_id: id })}>
     {implementation_key}
   </Link>
 );
@@ -12,7 +12,6 @@ export const RuleImplementationLink = ({ id, implementation_key, rule_id }) => (
 RuleImplementationLink.propTypes = {
   id: PropTypes.number,
   implementation_key: PropTypes.string,
-  rule_id: PropTypes.number
 };
 
 export default RuleImplementationLink;

package/src/components/RuleImplementationProperties.js

@@ -3,7 +3,7 @@ import React from "react";
 import PropTypes from "prop-types";
 import { FormattedMessage } from "react-intl";
 import { connect } from "react-redux";
-import { Grid, Label, Segment } from "semantic-ui-react";
+import { Grid, Label, Segment, List } from "semantic-ui-react";
 import InformationSummary from "./InformationSummary";
 import ImplementationSummary from "./ImplementationSummary";
 import RawContent from "./RawContent";
@@ -33,6 +33,17 @@ export const RuleImplementationProperties = ({
             </Label>
           </Grid.Column>
         </Grid.Row>
+        {!_.isNil(ruleImplementation?.domain) && (
+          <List size="big" relaxed>
+            <List.Item>
+              <List.Header>
+                <FormattedMessage id="quality.domain" />
+              </List.Header>
+
+              <List.Content>{ruleImplementation?.domain.name}</List.Content>
+            </List.Item>
+          </List>
+        )}
         <Grid.Row>
           <Grid.Column width={10}>
             <InformationSummary ruleImplementation={ruleImplementation} />
@@ -72,19 +83,7 @@ const mapStateToProps = ({
   templates,
   ruleImplementationLoading,
 }) => ({
-  ruleImplementation: _.pick([
-    ...summarySteps,
-    "populations",
-    "segments",
-    "executable",
-    "event_type",
-    "event_message",
-    "event_inserted_at",
-    "result_type",
-    "minimum",
-    "goal",
-    "df_content",
-  ])(ruleImplementation),
+  ruleImplementation,
   ruleImplementationRaw,
   templateImpl: _.find(_.propEq("name", ruleImplementation.df_name))(templates),
   ruleImplementationLoaded:

package/src/components/RuleImplementationResultTabs.js

@@ -7,14 +7,13 @@ import { compose } from "redux";
 import { connect } from "react-redux";
 import { FormattedMessage } from "react-intl";
 import {
-  RULE_IMPLEMENTATION_RESULT_DETAILS,
-  RULE_IMPLEMENTATION_RESULT_SEGMENTS_RESULTS,
-  RULE_IMPLEMENTATION_RESULT_REMEDIATION_PLAN,
+  IMPLEMENTATION_RESULT_DETAILS,
+  IMPLEMENTATION_RESULT_SEGMENTS_RESULTS,
+  IMPLEMENTATION_RESULT_REMEDIATION_PLAN,
   linkTo,
 } from "@truedat/core/routes";
 
 export const RuleImplementationResultTabs = ({
-  rule,
   ruleImplementation,
   ruleResult,
   match,
@@ -24,10 +23,9 @@ export const RuleImplementationResultTabs = ({
   const renderSegmentResult = () => {
     return ruleResult.has_segments ? (
       <Menu.Item
-        active={match.path === RULE_IMPLEMENTATION_RESULT_SEGMENTS_RESULTS}
+        active={match.path === IMPLEMENTATION_RESULT_SEGMENTS_RESULTS}
         as={Link}
-        to={linkTo.RULE_IMPLEMENTATION_RESULT_SEGMENTS_RESULTS({
-          id: rule.id,
+        to={linkTo.IMPLEMENTATION_RESULT_SEGMENTS_RESULTS({
           implementation_id: ruleImplementation.id,
           rule_result_id: ruleResult.id,
         })}
@@ -43,10 +41,9 @@ export const RuleImplementationResultTabs = ({
 
     return renderCondition ? (
       <Menu.Item
-        active={match.path === RULE_IMPLEMENTATION_RESULT_REMEDIATION_PLAN}
+        active={match.path === IMPLEMENTATION_RESULT_REMEDIATION_PLAN}
         as={Link}
-        to={linkTo.RULE_IMPLEMENTATION_RESULT_REMEDIATION_PLAN({
-          id: rule.id,
+        to={linkTo.IMPLEMENTATION_RESULT_REMEDIATION_PLAN({
           implementation_id: ruleImplementation.id,
           rule_result_id: ruleResult.id,
         })}
@@ -56,29 +53,25 @@ export const RuleImplementationResultTabs = ({
     ) : null;
   };
 
-  return _.isEmpty(ruleImplementation) || _.isEmpty(rule) ? null : (
-    <>
-      <Menu attached="top" pointing secondary tabular>
-        <Menu.Item
-          active={match.path === RULE_IMPLEMENTATION_RESULT_DETAILS}
-          as={Link}
-          to={linkTo.RULE_IMPLEMENTATION_RESULT_DETAILS({
-            id: rule.id,
-            implementation_id: ruleImplementation.id,
-            rule_result_id: ruleResult.id,
-          })}
-        >
-          <FormattedMessage id="tabs.dq.ruleImplementationResult.info" />
-        </Menu.Item>
-        {renderSegmentResult()}
-        {renderRemediationPlan()}
-      </Menu>
-    </>
+  return _.isEmpty(ruleImplementation) ? null : (
+    <Menu attached="top" pointing secondary tabular>
+      <Menu.Item
+        active={match.path === IMPLEMENTATION_RESULT_DETAILS}
+        as={Link}
+        to={linkTo.IMPLEMENTATION_RESULT_DETAILS({
+          implementation_id: ruleImplementation.id,
+          rule_result_id: ruleResult.id,
+        })}
+      >
+        <FormattedMessage id="tabs.dq.ruleImplementationResult.info" />
+      </Menu.Item>
+      {renderSegmentResult()}
+      {renderRemediationPlan()}
+    </Menu>
   );
 };
 
 RuleImplementationResultTabs.propTypes = {
-  rule: PropTypes.object,
   ruleResult: PropTypes.object,
   ruleImplementation: PropTypes.object,
   match: PropTypes.object,
@@ -86,12 +79,11 @@ RuleImplementationResultTabs.propTypes = {
   templates: PropTypes.array,
 };
 
-const mapStateToProps = (
-  { rule, ruleImplementation, remediationActions, templates },
-  ownProps
-) => ({
-  rule,
-  ruleResult: ownProps.ruleResult,
+const mapStateToProps = ({
+  ruleImplementation,
+  remediationActions,
+  templates,
+}) => ({
   ruleImplementation,
   authCreateRemediation: _.has("create")(remediationActions),
   templates,

package/src/components/RuleImplementationResults.js

@@ -21,14 +21,13 @@ export const getCustomColumnsWithData = (ruleResults, columns) =>
   )(columns);
 
 export const RuleImplementationResults = ({
-  rule,
   ruleImplementation,
   customColumns,
   isAdmin,
 }) => {
   const { formatMessage, locale } = useIntl();
 
-  if (_.isEmpty(rule) || _.isEmpty(ruleImplementation)) return null;
+  if (_.isEmpty(ruleImplementation)) return null;
 
   const ruleResults = ruleImplementation.results;
   const optionalColumns = getOptionalColumnsWithData(ruleResults);
@@ -111,7 +110,6 @@ export const RuleImplementationResults = ({
                 customColumns={customColumns}
                 isAdmin={isAdmin}
                 ruleImplementation={ruleImplementation}
-                rule={rule}
               />
             ))}
           </Table.Body>
@@ -123,14 +121,11 @@ export const RuleImplementationResults = ({
 
 RuleImplementationResults.propTypes = {
   ruleImplementation: PropTypes.object,
-  rule: PropTypes.object,
   customColumns: PropTypes.array,
   isAdmin: PropTypes.bool,
-  ruleResult: PropTypes.object,
 };
 
 const mapStateToProps = (state) => ({
-  rule: state.rule,
   ruleImplementation: state.ruleImplementation,
   customColumns: getCustomColumnsWithData(
     state.ruleImplementation?.results,

package/src/components/RuleImplementationResultsLink.js

@@ -3,15 +3,10 @@ import PropTypes from "prop-types";
 import { Link } from "react-router-dom";
 import { linkTo } from "@truedat/core/routes";
 
-export const RuleImplementationResultsLink = ({
-  id,
-  implementation_key,
-  rule_id
-}) => (
+export const RuleImplementationResultsLink = ({ id, implementation_key }) => (
   <Link
-    to={linkTo.RULE_IMPLEMENTATION_RESULTS({
-      id: rule_id,
-      implementation_id: id
+    to={linkTo.IMPLEMENTATION_RESULTS({
+      implementation_id: id,
     })}
   >
     {implementation_key}
@@ -21,7 +16,6 @@ export const RuleImplementationResultsLink = ({
 RuleImplementationResultsLink.propTypes = {
   id: PropTypes.number,
   implementation_key: PropTypes.string,
-  rule_id: PropTypes.number
 };
 
 export default RuleImplementationResultsLink;