merge with 2.0.0-m3

scm-ui/src/repos/permissions/components/CreatePermissionForm.js

@@ -0,0 +1,122 @@
+// @flow
+import React from "react";
+import { translate } from "react-i18next";
+import { Checkbox, InputField, SubmitButton } from "@scm-manager/ui-components";
+import TypeSelector from "./TypeSelector";
+import type {
+  PermissionCollection,
+  PermissionEntry
+} from "@scm-manager/ui-types";
+import * as validator from "./permissionValidation";
+
+type Props = {
+  t: string => string,
+  createPermission: (permission: PermissionEntry) => void,
+  loading: boolean,
+  currentPermissions: PermissionCollection
+};
+
+type State = {
+  name: string,
+  type: string,
+  groupPermission: boolean,
+  valid: boolean
+};
+
+class CreatePermissionForm extends React.Component<Props, State> {
+  constructor(props: Props) {
+    super(props);
+
+    this.state = {
+      name: "",
+      type: "READ",
+      groupPermission: false,
+      valid: true
+    };
+  }
+
+  render() {
+    const { t, loading } = this.props;
+    const { name, type, groupPermission } = this.state;
+
+    return (
+      <div>
+        <h2 className="subtitle">
+          {t("permission.add-permission.add-permission-heading")}
+        </h2>
+        <form onSubmit={this.submit}>
+          <InputField
+            label={t("permission.name")}
+            value={name ? name : ""}
+            onChange={this.handleNameChange}
+            validationError={!this.state.valid}
+            errorMessage={t("permission.add-permission.name-input-invalid")}
+          />
+          <Checkbox
+            label={t("permission.group-permission")}
+            checked={groupPermission ? groupPermission : false}
+            onChange={this.handleGroupPermissionChange}
+          />
+          <TypeSelector
+            label={t("permission.type")}
+            handleTypeChange={this.handleTypeChange}
+            type={type ? type : "READ"}
+          />
+          <SubmitButton
+            label={t("permission.add-permission.submit-button")}
+            loading={loading}
+            disabled={!this.state.valid || this.state.name == ""}
+          />
+        </form>
+      </div>
+    );
+  }
+
+  submit = e => {
+    this.props.createPermission({
+      name: this.state.name,
+      type: this.state.type,
+      groupPermission: this.state.groupPermission
+    });
+    this.removeState();
+    e.preventDefault();
+  };
+
+  removeState = () => {
+    this.setState({
+      name: "",
+      type: "READ",
+      groupPermission: false,
+      valid: true
+    });
+  };
+
+  handleTypeChange = (type: string) => {
+    this.setState({
+      type: type
+    });
+  };
+
+  handleNameChange = (name: string) => {
+    this.setState({
+      name: name,
+      valid: validator.isPermissionValid(
+        name,
+        this.state.groupPermission,
+        this.props.currentPermissions
+      )
+    });
+  };
+  handleGroupPermissionChange = (groupPermission: boolean) => {
+    this.setState({
+      groupPermission: groupPermission,
+      valid: validator.isPermissionValid(
+        this.state.name,
+        groupPermission,
+        this.props.currentPermissions
+      )
+    });
+  };
+}
+
+export default translate("repos")(CreatePermissionForm);

scm-ui/src/repos/permissions/components/TypeSelector.js

@@ -0,0 +1,40 @@
+// @flow
+import React from "react";
+import { translate } from "react-i18next";
+import {
+  Select
+} from "@scm-manager/ui-components";
+
+type Props = {
+  t: string => string,
+  handleTypeChange: string => void,
+  type: string,
+  loading?: boolean
+};
+
+class TypeSelector extends React.Component<Props> {
+  render() {
+    const { type, handleTypeChange, loading } = this.props;
+    const types = ["READ", "OWNER", "WRITE"];
+
+    return (
+      <Select
+        onChange={handleTypeChange}
+        value={type ? type : "READ"}
+        options={this.createSelectOptions(types)}
+        loading={loading}
+      />
+    );
+  }
+
+  createSelectOptions(types: string[]) {
+    return types.map(type => {
+      return {
+        label: type,
+        value: type
+      };
+    });
+  }
+}
+
+export default translate("permissions")(TypeSelector);

scm-ui/src/repos/permissions/components/buttons/DeletePermissionButton.js

@@ -0,0 +1,73 @@
+// @flow
+import React from "react";
+import { translate } from "react-i18next";
+import type { Permission } from "@scm-manager/ui-types";
+import { confirmAlert, DeleteButton } from "@scm-manager/ui-components";
+
+type Props = {
+  permission: Permission,
+  namespace: string,
+  repoName: string,
+  confirmDialog?: boolean,
+  t: string => string,
+  deletePermission: (
+    permission: Permission,
+    namespace: string,
+    repoName: string
+  ) => void,
+  loading: boolean
+};
+
+class DeletePermissionButton extends React.Component<Props> {
+  static defaultProps = {
+    confirmDialog: true
+  };
+
+  deletePermission = () => {
+    this.props.deletePermission(
+      this.props.permission,
+      this.props.namespace,
+      this.props.repoName
+    );
+  };
+
+  confirmDelete = () => {
+    const { t } = this.props;
+    confirmAlert({
+      title: t("permission.delete-permission-button.confirm-alert.title"),
+      message: t("permission.delete-permission-button.confirm-alert.message"),
+      buttons: [
+        {
+          label: t("permission.delete-permission-button.confirm-alert.submit"),
+          onClick: () => this.deletePermission()
+        },
+        {
+          label: t("permission.delete-permission-button.confirm-alert.cancel"),
+          onClick: () => null
+        }
+      ]
+    });
+  };
+
+  isDeletable = () => {
+    return this.props.permission._links.delete;
+  };
+
+  render() {
+    const { confirmDialog, loading, t } = this.props;
+    const action = confirmDialog ? this.confirmDelete : this.deletePermission;
+
+    if (!this.isDeletable()) {
+      return null;
+    }
+    return (
+      <DeleteButton
+        label={t("permission.delete-permission-button.label")}
+        action={action}
+        loading={loading}
+      />
+    );
+  }
+}
+
+export default translate("repos")(DeletePermissionButton);

scm-ui/src/repos/permissions/components/buttons/DeletePermissionButton.test.js

@@ -0,0 +1,98 @@
+import React from "react";
+import { mount, shallow } from "enzyme";
+import "../../../../tests/enzyme";
+import "../../../../tests/i18n";
+import DeletePermissionButton from "./DeletePermissionButton";
+
+import { confirmAlert } from "@scm-manager/ui-components";
+import ReactRouterEnzymeContext from "react-router-enzyme-context";
+jest.mock("@scm-manager/ui-components", () => ({
+  confirmAlert: jest.fn(),
+  DeleteButton: require.requireActual("@scm-manager/ui-components").DeleteButton
+}));
+
+describe("DeletePermissionButton", () => {
+  const options = new ReactRouterEnzymeContext();
+
+  it("should render nothing, if the delete link is missing", () => {
+    const permission = {
+      _links: {}
+    };
+
+    const navLink = shallow(
+      <DeletePermissionButton
+        permission={permission}
+        deletePermission={() => {}}
+      />,
+      options.get()
+    );
+    expect(navLink.text()).toBe("");
+  });
+
+  it("should render the navLink", () => {
+    const permission = {
+      _links: {
+        delete: {
+          href: "/permission"
+        }
+      }
+    };
+
+    const navLink = mount(
+      <DeletePermissionButton
+        permission={permission}
+        deletePermission={() => {}}
+      />,
+      options.get()
+    );
+    expect(navLink.text()).not.toBe("");
+  });
+
+  it("should open the confirm dialog on button click", () => {
+    const permission = {
+      _links: {
+        delete: {
+          href: "/permission"
+        }
+      }
+    };
+
+    const button = mount(
+      <DeletePermissionButton
+        permission={permission}
+        deletePermission={() => {}}
+      />,
+      options.get()
+    );
+    button.find("button").simulate("click");
+
+    expect(confirmAlert.mock.calls.length).toBe(1);
+  });
+
+  it("should call the delete permission function with delete url", () => {
+    const permission = {
+      _links: {
+        delete: {
+          href: "/permission"
+        }
+      }
+    };
+
+    let calledUrl = null;
+    function capture(permission) {
+      calledUrl = permission._links.delete.href;
+    }
+
+    const button = mount(
+      <DeletePermissionButton
+        permission={permission}
+        confirmDialog={false}
+        deletePermission={capture}
+      />,
+      options.get()
+    );
+    button.find("button").simulate("click");
+
+    expect(calledUrl).toBe("/permission");
+  });
+});

scm-ui/src/repos/permissions/components/permissionValidation.js

@@ -0,0 +1,23 @@
+// @flow
+import { validation } from "@scm-manager/ui-components";
+import type {
+  PermissionCollection,
+} from "@scm-manager/ui-types";
+const isNameValid = validation.isNameValid;
+
+export { isNameValid };
+
+export const isPermissionValid = (name: string, groupPermission: boolean, permissions: PermissionCollection) => {
+  return isNameValid(name) && !currentPermissionIncludeName(name, groupPermission, permissions);
+};
+
+const currentPermissionIncludeName = (name: string, groupPermission: boolean, permissions: PermissionCollection) => {
+  for (let i = 0; i < permissions.length; i++) {
+    if (
+      permissions[i].name === name &&
+      permissions[i].groupPermission == groupPermission
+    )
+      return true;
+  }
+  return false;
+};

scm-ui/src/repos/permissions/components/permissionValidation.test.js

@@ -0,0 +1,66 @@
+//@flow
+import * as validator from "./permissionValidation";
+
+describe("permission validation", () => {
+  it("should return true if permission is valid and does not exist", () => {
+    const permissions = [];
+    const name = "PermissionName";
+    const groupPermission = false;
+
+    expect(
+      validator.isPermissionValid(name, groupPermission, permissions)
+    ).toBe(true);
+  });
+
+  it("should return true if permission is valid and does not exists with same group permission", () => {
+    const permissions = [
+      {
+        name: "PermissionName",
+        groupPermission: true,
+        type: "READ"
+      }
+    ];
+    const name = "PermissionName";
+    const groupPermission = false;
+
+    expect(
+      validator.isPermissionValid(name, groupPermission, permissions)
+    ).toBe(true);
+  });
+
+  it("should return false if permission is valid but exists", () => {
+    const permissions = [
+      {
+        name: "PermissionName",
+        groupPermission: false,
+        type: "READ"
+      }
+    ];
+    const name = "PermissionName";
+    const groupPermission = false;
+
+    expect(
+      validator.isPermissionValid(name, groupPermission, permissions)
+    ).toBe(false);
+  });
+
+  it("should return false if permission does not exist but is invalid", () => {
+    const permissions = [];
+    const name = "@PermissionName";
+    const groupPermission = false;
+
+    expect(
+      validator.isPermissionValid(name, groupPermission, permissions)
+    ).toBe(false);
+  });
+
+  it("should return false if permission is not valid and does not exist", () => {
+    const permissions = [];
+    const name = "@PermissionName";
+    const groupPermission = false;
+
+    expect(
+      validator.isPermissionValid(name, groupPermission, permissions)
+    ).toBe(false);
+  });
+});