Merge branch 'develop' of github.com:humanprotocol/human-protocol into kb/3161

Author: KirillKirill

packages/apps/job-launcher/client/src/components/Jobs/Create/AudinoJobRequestForm.tsx

@@ -6,6 +6,7 @@ import { NetworkSelect } from '../../../components/NetworkSelect';
 import { IS_MAINNET } from '../../../constants/chains';
 import { useCreateJobPageUI } from '../../../providers/CreateJobPageUIProvider';
 import { JobType, PayMethod } from '../../../types';
+import { AudinoJobRequestForm } from './AudinoJobRequestForm';
 import { CvatJobRequestForm } from './CvatJobRequestForm';
 import { FortuneJobRequestForm } from './FortuneJobRequestForm';
 import { HCaptchaJobRequestForm } from './HCaptchaJobRequestForm';
@@ -62,12 +63,13 @@ export const CreateJob = () => {
             }
           >
             {!IS_MAINNET && (
-              <MenuItem value={JobType.Fortune}>Fortune</MenuItem>
+              <MenuItem value={JobType.FORTUNE}>Fortune</MenuItem>
             )}
             <MenuItem value={JobType.CVAT}>CVAT</MenuItem>
             {/* {!IS_MAINNET && (
               <MenuItem value={JobType.HCAPTCHA}>hCaptcha</MenuItem>
             )} */}
+            {!IS_MAINNET && <MenuItem value={JobType.AUDINO}>Audino</MenuItem>}
           </Select>
         </FormControl>
         <NetworkSelect
@@ -81,9 +83,10 @@ export const CreateJob = () => {
           }
         />
       </Box>
-      {jobRequest.jobType === JobType.Fortune && <FortuneJobRequestForm />}
+      {jobRequest.jobType === JobType.FORTUNE && <FortuneJobRequestForm />}
       {jobRequest.jobType === JobType.CVAT && <CvatJobRequestForm />}
       {jobRequest.jobType === JobType.HCAPTCHA && <HCaptchaJobRequestForm />}
+      {jobRequest.jobType === JobType.AUDINO && <AudinoJobRequestForm />}
     </Box>
   );
 };

packages/apps/job-launcher/client/src/components/Jobs/Create/CreateJob.tsx

@@ -223,8 +223,9 @@ export const CryptoPayForm = ({
           fortuneRequest,
           cvatRequest,
           hCaptchaRequest,
+          audinoRequest,
         } = jobRequest;
-        if (jobType === JobType.Fortune && fortuneRequest) {
+        if (jobType === JobType.FORTUNE && fortuneRequest) {
           await jobService.createFortuneJob(
             chainId,
             fortuneRequest,
@@ -242,6 +243,14 @@ export const CryptoPayForm = ({
           );
         } else if (jobType === JobType.HCAPTCHA && hCaptchaRequest) {
           await jobService.createHCaptchaJob(chainId, hCaptchaRequest);
+        } else if (jobType === JobType.AUDINO && audinoRequest) {
+          await jobService.createAudinoJob(
+            chainId,
+            audinoRequest,
+            paymentTokenSymbol,
+            Number(amount),
+            fundTokenSymbol,
+          );
         }
         onFinish();
       } catch (err) {

packages/apps/job-launcher/client/src/components/Jobs/Create/CryptoPayForm.tsx

@@ -718,9 +718,9 @@ export const CvatJobRequestForm = () => {
                         </MenuItem>
                       ))}
                     </Select>
-                    {errors.dataRegion && (
+                    {errors.gtRegion && (
                       <FormHelperText sx={{ mx: '14px', mt: '3px' }} error>
-                        {errors.dataRegion}
+                        {errors.gtRegion}
                       </FormHelperText>
                     )}
                   </FormControl>

packages/apps/job-launcher/client/src/components/Jobs/Create/CvatJobRequestForm.tsx

@@ -29,6 +29,7 @@ import { CURRENCY } from '../../../constants/payment';
 import { useCreateJobPageUI } from '../../../providers/CreateJobPageUIProvider';
 import { useSnackbar } from '../../../providers/SnackProvider';
 import {
+  createAudinoJob,
   createCvatJob,
   createFortuneJob,
   createHCaptchaJob,
@@ -248,11 +249,17 @@ export const FiatPayForm = ({
       }
 
       // create job
-      const { jobType, chainId, fortuneRequest, cvatRequest, hCaptchaRequest } =
-        jobRequest;
+      const {
+        jobType,
+        chainId,
+        fortuneRequest,
+        cvatRequest,
+        hCaptchaRequest,
+        audinoRequest,
+      } = jobRequest;
       if (!chainId) return;
 
-      if (jobType === JobType.Fortune && fortuneRequest) {
+      if (jobType === JobType.FORTUNE && fortuneRequest) {
         await createFortuneJob(
           chainId,
           fortuneRequest,
@@ -270,6 +277,14 @@ export const FiatPayForm = ({
         );
       } else if (jobType === JobType.HCAPTCHA && hCaptchaRequest) {
         await createHCaptchaJob(chainId, hCaptchaRequest);
+      } else if (jobType === JobType.AUDINO && audinoRequest) {
+        await createAudinoJob(
+          chainId,
+          audinoRequest,
+          CURRENCY.usd,
+          amount,
+          tokenSymbol,
+        );
       }
 
       // Update balance and finish payment

packages/apps/job-launcher/client/src/components/Jobs/Create/FiatPayForm.tsx

@@ -5,6 +5,7 @@ import {
   StorageProviders,
   GCSRegions,
   AWSRegions,
+  AudinoJobType,
 } from '../../../types';
 
 export const mapCvatFormValues = (
@@ -67,3 +68,40 @@ export const mapFortuneFormValues = (
       : [],
   };
 };
+
+export const mapAudinoFormValues = (
+  jobRequest: JobRequest,
+  qualificationsOptions: Qualification[],
+) => {
+  const { audinoRequest } = jobRequest;
+
+  return {
+    type: audinoRequest?.type || AudinoJobType.AUDIO_TRANSCRIPTION,
+    labels: audinoRequest?.labels?.map((label) => label.name) || [],
+    description: audinoRequest?.description || '',
+    qualifications: audinoRequest?.qualifications
+      ? qualificationsOptions.filter((q: Qualification) =>
+          audinoRequest?.qualifications?.includes(q.reference),
+        )
+      : [],
+
+    dataProvider:
+      audinoRequest?.data?.dataset?.provider || StorageProviders.AWS,
+    dataRegion:
+      (audinoRequest?.data?.dataset?.region as AWSRegions | GCSRegions) || '',
+    dataBucketName: audinoRequest?.data?.dataset?.bucketName || '',
+    dataPath: audinoRequest?.data?.dataset?.path || '',
+
+    gtProvider: audinoRequest?.groundTruth?.provider || StorageProviders.AWS,
+    gtRegion:
+      (audinoRequest?.groundTruth?.region as AWSRegions | GCSRegions) || '',
+    gtBucketName: audinoRequest?.groundTruth?.bucketName || '',
+    gtPath: audinoRequest?.groundTruth?.path || '',
+
+    userGuide: audinoRequest?.userGuide || '',
+    accuracyTarget: audinoRequest?.accuracyTarget || 50,
+
+    audioDuration: audinoRequest?.audioDuration || 0,
+    segmentDuration: audinoRequest?.segmentDuration || 0,
+  };
+};

packages/apps/job-launcher/client/src/components/Jobs/Create/helpers.ts

@@ -8,27 +8,25 @@ import { FundingMethod } from './FundingMethod';
 import { LaunchSuccess } from './LaunchSuccess';
 import { PayJob } from './PayJob';
 
+const supportedJobTypes = Object.values(JobType);
+
+function isSupportedJobType(jobType: string): jobType is JobType {
+  return supportedJobTypes.includes(jobType as JobType);
+}
+
 export const CreateJobView = () => {
   const { step, changePayMethod, setStep, updateJobRequest } =
     useCreateJobPageUI();
   const [searchParams] = useSearchParams();
 
   useEffect(() => {
-    const jobType = searchParams.get('jobType');
-    const supportedJobTypes = ['fortune', 'cvat', 'hcaptcha'];
+    const jobType = searchParams.get('jobType') || '';
 
-    if (jobType && supportedJobTypes.includes(jobType.toLowerCase())) {
+    if (isSupportedJobType(jobType)) {
       changePayMethod(PayMethod.Fiat);
       setStep(CreateJobStep.CreateJob);
 
-      updateJobRequest({
-        jobType:
-          jobType === 'fortune'
-            ? JobType.Fortune
-            : jobType === 'cvat'
-              ? JobType.CVAT
-              : JobType.HCAPTCHA,
-      });
+      updateJobRequest({ jobType });
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);

packages/apps/job-launcher/client/src/components/Jobs/Create/index.tsx

@@ -89,3 +89,38 @@ export const HCaptchaJobRequesteValidationSchema = Yup.object().shape({
   images: Yup.array().of(Yup.string().url('Invalid Image URL')),
   qualifications: Yup.array().of(Yup.object()),
 });
+
+export const AudinoJobRequestValidationSchema = Yup.object().shape({
+  labels: Yup.array().of(Yup.string()).min(1, 'At least one label is required'),
+  description: Yup.string().required('Description is required'),
+  dataProvider: Yup.string().required('Provider is required'),
+  dataRegion: Yup.string().required('Region is required'),
+  dataBucketName: Yup.string().required('Bucket name is required'),
+  dataPath: Yup.string().optional(),
+  gtProvider: Yup.string().required('Provider is required'),
+  gtRegion: Yup.string().required('Region is required'),
+  gtBucketName: Yup.string().required('Bucket name is required'),
+  gtPath: Yup.string().optional(),
+  userGuide: Yup.string()
+    .required('User Guide URL is required')
+    .url('Invalid URL'),
+  accuracyTarget: Yup.number()
+    .required('Accuracy target is required')
+    .moreThan(0, 'Accuracy target must be greater than 0')
+    .max(100, 'Accuracy target must be less than or equal to 100'),
+  qualifications: Yup.array().of(Yup.object()),
+
+  audioDuration: Yup.number()
+    .required('Audio duration is required')
+    .moreThan(0, 'Audio duration must be greater than 0')
+    .max(31536000, 'Audio duration must be less than or equal to 31536000'), // one year in seconds
+  segmentDuration: Yup.number()
+    .required('Segment duration is required')
+    .moreThan(0, 'Segment duration must be greater than 0')
+    .when('$audioDuration', ([audioDuration], schema) => {
+      return schema.max(
+        audioDuration * 1000,
+        'Segment duration should not exceed audio duration',
+      );
+    }),
+});

packages/apps/job-launcher/client/src/components/Jobs/Create/schema.ts

@@ -20,7 +20,7 @@ const initialData: CreateJobPageUIType = {
   step: CreateJobStep.FundingMethod,
   payMethod: PayMethod.Crypto,
   jobRequest: {
-    jobType: JobType.Fortune,
+    jobType: JobType.FORTUNE,
     chainId: undefined,
   },
   reset: () => {},
@@ -45,7 +45,7 @@ export const CreateJobPageUIProvider = ({
   const [step, setStep] = useState<CreateJobStep>(CreateJobStep.FundingMethod);
   const [payMethod, setPayMethod] = useState<PayMethod>(PayMethod.Crypto);
   const [jobRequest, setJobRequest] = useState<JobRequest>({
-    jobType: IS_MAINNET ? JobType.CVAT : JobType.Fortune,
+    jobType: IS_MAINNET ? JobType.CVAT : JobType.FORTUNE,
     chainId:
       chain?.id && SUPPORTED_CHAIN_IDS.includes(chain?.id)
         ? chain?.id
@@ -77,7 +77,7 @@ export const CreateJobPageUIProvider = ({
     setStep(CreateJobStep.FundingMethod);
     setPayMethod(PayMethod.Crypto);
     setJobRequest({
-      jobType: JobType.Fortune,
+      jobType: JobType.FORTUNE,
     });
   };
 

packages/apps/job-launcher/client/src/providers/CreateJobPageUIProvider.tsx

@@ -8,6 +8,8 @@ import {
   JobDetailsResponse,
   HCaptchaRequest,
   FortuneFinalResult,
+  AudinoRequest,
+  CreateAudinoJobRequest,
 } from '../types';
 import api from '../utils/api';
 import { getFilenameFromContentDisposition } from '../utils/string';
@@ -66,6 +68,33 @@ export const createHCaptchaJob = async (
   });
 };
 
+export const createAudinoJob = async (
+  chainId: number,
+  data: AudinoRequest,
+  paymentCurrency: string,
+  paymentAmount: number | string,
+  escrowFundToken: string,
+) => {
+  const body: CreateAudinoJobRequest = {
+    chainId,
+    requesterDescription: data.description,
+    paymentCurrency,
+    paymentAmount: Number(paymentAmount),
+    escrowFundToken,
+    data: data.data,
+    labels: data.labels,
+    minQuality: Number(data.accuracyTarget) / 100,
+    groundTruth: data.groundTruth,
+    userGuide: data.userGuide,
+    type: data.type,
+    qualifications: data.qualifications,
+    audioDuration: Number(data.audioDuration),
+    segmentDuration: Number(data.segmentDuration),
+  };
+
+  await api.post('/job/audino', body);
+};
+
 export const getJobList = async ({
   chainId = ChainId.ALL,
   status,