gilad code review

######  details.js ######

 server.route({
    method: 'PUT',
    path: '/orgs/{idOrg}/appFormField/reorder',
    config: {
      tags: ['api'],
      description: 'Reorder app form fields',
      auth: {
        strategy: 'session',
        scope: ['torii-admin', `${SCOPES.APPLICATIONS_WRITE}-{params.idOrg}`]
      },
      validate: {
        params: {
          idOrg: Joi.number().integer()
        },
        payload: {
          changes: Joi.array().required().items(Joi.object({
            idField: Joi.number().integer().required(),
            position: Joi.number().integer().required(),
            idGroup: Joi.number().integer()
          }).required())
        }
      },
      app: {
        audit: {
          type: 'reorder_app_form_fields',
          properties: ({ params, payload }) => ({ idOrg: params.idOrg, changes: payload.changes })
        }
      }
    },
    handler: async (request, h) => {
      const { idOrg } = request.params
      const { changes: positions } = request.payload
      const idFields = _.map(positions, "idField")

      const existingFields = await AppDetails.getFieldsByIds({ idFields, idOrg, fields: ["idOrg"] })

      const intersectionLength = _.intersection(_.map(existingFields, "id"),idFields).length;
      if (!(intersectionLength === idFields.length && idFields.length === existingFields.length )) {
        return  Boom.notFound('Some or all fields from ${idFields} not found')
      }

      let containsOnlyCustomFieldsForGroupReordering = true;

      _.filter(positions,"idGroup").forEach((position) => {
        if (_.find(existingFields, (existingField) => existingField.id === position.idField && existingField.idOrg !== idOrg)) {
          containsOnlyCustomFieldsForGroupReordering = false;
        return;
      }
    })

      if (!containsOnlyCustomFieldsForGroupReordering) {
        return Boom.notAcceptable('User can only move custom fields between groups')
      }

      await AppDetails.setFieldsPositions({ idOrg, positions })
      const fields = await AppDetails.getFieldsByIds({ idFields, idOrg })
      return { fields }
    }
  })


##### appDetails.js ######

static async setFieldsPositions ({ idOrg, positions }) {

    const form_fields_info_data = [];
    const form_fields_data = [];

    positions.forEach((position) => {
      position.idGroup && form_fields_data.push({ id: position.idField, idGroup: position.idGroup })
      form_fields_info_data.push({ idOrg, idField: position.idField, position: position.position });
    });


    await upsert('form_fields_info', form_fields_info_data, ['idOrg', 'idField', 'position'])
    if (form_fields_data.length > 0) {
      await upsert('form_fields', form_fields_data, ['id', 'idGroup'])
    }

    return true
  }
  
  
  
  ##### details.test.js
  
   describe('PUT /orgs/{idOrg}/appFormField/reorder', () => {
    const demoUser = {
      id: 2,
      idOrg: 5
    }

    const baseRequest = {
      method: 'PUT',
      url: '/orgs/100/appFormField/reorder',
      auth: {
        credentials: {
          user: demoUser,
          scope: ['torii-admin']
        },
        strategy: 'default'
      }
    }

    AppDetails.getFieldsByIds = jest.fn(async () => [
      {
        id: 1,
        idOrg: null,
      },
      {
        id: 15,
        idOrg: null,
      }
    ])

    AppDetails.setFieldsPositions = jest.fn(async () => {})

    it.only('should return 404 due to mismatch of fields', async () => {

      const requestWithMismatchingFields = {
        ...baseRequest,
        payload: {
          changes: [
            {
              idField: 1,
              position: 1,
            },
            {
              idField: 15,
              position: 4,
            },
            {
              idField: 18,
              position: 4,
            }
          ]
        }
      };

      const response2 = await server.inject(requestWithMismatchingFields)
      expect(response2.statusCode).toBe(404)
      // expect(response.result.message).toBe('Domains "example1.com, example3.com" are assigned to another organization')
    })

    it.only('should return 200', async () => {

      const requestWithValidFields = {
        ...baseRequest,
        payload: {
          changes: [
            {
              idField: 1,
              position: 1,
            },
            {
              idField: 15,
              position: 4,
            }

          ]
        }
      };

      const response1 = await server.inject(requestWithValidFields)
      expect(response1.statusCode).toBe(200)

    })

    it.only('should return 406 due to a request to move between groups a field with idOrg=null ', async () => {

      const requestWithValidFields = {
        ...baseRequest,
        payload: {
          changes: [
            {
              idField: 1,
              position: 1,
              idGroup: 6
            },
            {
              idField: 15,
              position: 4,
            }

          ]
        }
      };

      const response1 = await server.inject(requestWithValidFields)
      expect(response1.statusCode).toBe(406)

    })

  })


#### appDetails.test.js ####

const formFieldsInfo = [
  {
    id: 1,
    idOrg: 100,
    idField: 99,
    isShown: 1,
    isDeleted: 0,
    position: 10,
  },
  {
    id: 2,
    idOrg: 100,
    idField: 11,
    isShown: 1,
    isDeleted: 0,
    position: 20,
  },
  {
    id: 3,
    idOrg: 100,
    idField: 4,
    isShown: 1,
    isDeleted: 0,
    position: 30,
  }
]


describe('setFieldsPositions', () => {
    describe('validate setFieldPosition response', () => {
      it('should return true on success', async () => {

        let changes = _.map(formFieldsInfo, f => _.pick(f, ["idField", "position"]))
        _.first(changes).idGroup = _.first(formFields).idGroup;

        const reorderResponse = await AppDetails.setFieldsPositions({ idOrg: 100, positions: changes })
        expect(reorderResponse).toEqual(true)
      })
    })
  })