Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

6.9 kB

// $FlowFixMe
const { v4: uuid } = require('uuid');
// $FlowFixMe
const faker = require('faker');
// $FlowFixMe
const slugify = require('slugg');
// $FlowFixMe
const casual = require('casual').functions();
const { fromPlainText, toJSON } = require('../../../shared/draft-utils');

const randomAmount = ({ max, min }, cb) => {
  if (!max) throw new Error('randomAmount({ max }): max has to be defined!');
  const n = faker.random.number({ min: min || 0, max });
  let result = [];
  for (var i = 0; i < n; i++) {
    result.push(cb(i));
  }
  return result;
};

const generateUser = () => {
  const createdAt = faker.date.past(2);
  const name = faker.name.findName();
  return {
    id: uuid(),
    name,
    description: casual.short_description(),
    website: faker.internet.url(),
    username: faker.internet.userName(name),
    profilePhoto: faker.internet.avatar(),
    coverPhoto: faker.image.image(),
    email: faker.internet.email(name),
    providerId: uuid(),
    createdAt,
    // Make sure lastSeen is > createdAt
    lastSeen: faker.date.between(createdAt, new Date()),
  };
};

const generateUsersSettings = userId => {
  return {
    id: uuid(),
    userId,
    notifications: {
      types: {
        newMessageInThreads: {
          email: true,
        },
        newThreadCreated: {
          email: true,
        },
        dailyDigest: {
          email: true,
        },
        weeklyDigest: {
          email: true,
        },
      },
    },
  };
};

const generateCommunity = () => {
  const name = faker.company.companyName();

  return {
    id: uuid(),
    createdAt: faker.date.past(2),
    name,
    description: casual.short_description(),
    website: faker.internet.url(),
    profilePhoto: faker.image.business(),
    coverPhoto: faker.image.image(),
    slug: slugify(name),
  };
};

const generateChannel = communityId => {
  const name = faker.commerce.department();

  return {
    id: uuid(),
    communityId,
    createdAt: faker.date.past(2),
    name,
    description: casual.short_description(),
    slug: slugify(name),
    isPrivate: faker.random.boolean(),
    isDefault: false,
  };
};

const generateUsersCommunities = (communityId, userId) => {
  const isOwner = faker.random.boolean();
  // for ease of use, set to false
  const isModerator = false;
  // if user is either an admin or moderator, they have to be a member
  // otherwise random chance
  const isMember = isOwner || isModerator ? true : faker.random.boolean();
  // might be blocked as long as they aren't an admin, mod, or member
  const isBlocked =
    isOwner || isModerator || isMember ? false : faker.random.boolean();

  return {
    id: uuid(),
    createdAt: faker.date.past(2),
    communityId,
    userId,
    isOwner,
    isModerator,
    isMember,
    isBlocked,
    receiveNotifications: true,
    reputation: 1,
  };
};

const generateUsersChannels = (channels, usersCommunities, userId) => {
  // figure out which communities the user being evaulated is a member of
  let possibleCommunities = usersCommunities.filter(
    elem => elem.userId === userId
  );
  // make sure they are a member of the community
  possibleCommunities = possibleCommunities
    .filter(elem => elem.isMember || elem.isOwner || elem.isModerator)
    .map(elem => elem.communityId);
  let possibleChannels = channels.filter(
    channel => possibleCommunities.indexOf(channel.communityId) > -1
  );

  // for each of those communities, construct an array of channels that are in
  // that community
  // const possibleChannels = possibleCommunities.map(community => channels.filter(channel => channel.communityId === community.id))

  // for each of hte possible channels, generate a new usersChannels object
  const foo = possibleChannels.map(channel => {
    const isOwner = faker.random.boolean();
    // for ease of use, set to false
    const isModerator = false;
    // if user is either an admin or moderator, they have to be a member
    // otherwise random chance
    const isMember = isOwner || isModerator ? true : faker.random.boolean();
    // if a user is admin, mod, or member, they can't be pending, otherwise random
    const isPending =
      isOwner || isModerator || isMember ? false : faker.random.boolean();
    // might be blocked as long as they aren't an admin, mod, pending, or member
    const isBlocked =
      isOwner || isModerator || isMember || isPending
        ? false
        : faker.random.boolean();

    return {
      id: uuid(),
      createdAt: new Date(),
      channelId: channel.id,
      userId,
      isOwner,
      isModerator,
      isMember,
      isBlocked,
      isPending,
      receiveNotifications: true,
    };
  });
  return foo;
};

const generateThread = (communityId, channelId, creatorId) => {
  const content = {
    title: casual.title(),
    body: JSON.stringify(toJSON(fromPlainText(casual.text()))),
  };

  const createdAt = faker.date.past(2);

  return {
    id: uuid(),
    createdAt,
    creatorId,
    channelId,
    communityId,
    isPublished: faker.random.boolean(),
    content,
    type: 'DRAFTJS',
    lastActive: faker.date.between(createdAt, new Date()),
    edits: [
      {
        timestamp: createdAt,
        content,
      },
    ],
    modifiedAt: faker.date.between(createdAt, new Date()),
  };
};

const generateUsersThreads = (threadId, userId) => {
  const createdAt = faker.date.past(2);

  return {
    id: uuid(),
    createdAt,
    threadId,
    userId,
    isParticipant: true,
    receiveNotifications: true,
  };
};

const generateDirectMessageThread = users => {
  const createdAt = faker.date.past(2);
  const threadLastActive = faker.date.between(createdAt, faker.date.recent());

  return {
    id: uuid(),
    name: null,
    createdAt,
    threadLastActive,
  };
};

const generateUsersDirectMessageThreads = (threadId, userId) => {
  const createdAt = faker.date.past(2);
  const lastActive = faker.date.between(createdAt, faker.date.recent());
  const lastSeen = faker.date.between(createdAt, new Date());

  return {
    id: uuid(),
    createdAt,
    threadId,
    userId,
    lastActive,
    lastSeen,
    receiveNotifications: true,
  };
};

const generateMessage = (senderId, threadId, threadType) => {
  return {
    id: uuid(),
    threadType,
    threadId,
    senderId,
    content: {
      body: casual.text(),
    },
    messageType: 'text',
    timestamp: faker.date.past(2),
  };
};

const generateReaction = (userId, messageId) => {
  return {
    id: uuid(),
    messageId,
    userId,
    timestamp: faker.date.past(2),
    type: 'like',
  };
};

module.exports = {
  randomAmount,
  generateUser,
  generateUsersSettings,
  generateCommunity,
  generateChannel,
  generateUsersCommunities,
  generateUsersChannels,
  generateUsersDirectMessageThreads,
  generateThread,
  generateUsersThreads,
  generateMessage,
  generateReaction,
  generateDirectMessageThread,
};

	// $FlowFixMe
	const { v4: uuid } = require('uuid');
	// $FlowFixMe
	const faker = require('faker');
	// $FlowFixMe
	const slugify = require('slugg');
	// $FlowFixMe
	const casual = require('casual').functions();
	const { fromPlainText, toJSON } = require('../../../shared/draft-utils');

	const randomAmount = ({ max, min }, cb) => {
	if (!max) throw new Error('randomAmount({ max }): max has to be defined!');
	const n = faker.random.number({ min: min \|\| 0, max });
	let result = [];
	for (var i = 0; i < n; i++) {
	result.push(cb(i));
	}
	return result;
	};

	const generateUser = () => {
	const createdAt = faker.date.past(2);
	const name = faker.name.findName();
	return {
	id: uuid(),
	name,
	description: casual.short_description(),
	website: faker.internet.url(),
	username: faker.internet.userName(name),
	profilePhoto: faker.internet.avatar(),
	coverPhoto: faker.image.image(),
	email: faker.internet.email(name),
	providerId: uuid(),
	createdAt,
	// Make sure lastSeen is > createdAt
	lastSeen: faker.date.between(createdAt, new Date()),
	};
	};

	const generateUsersSettings = userId => {
	return {
	id: uuid(),
	userId,
	notifications: {
	types: {
	newMessageInThreads: {
	email: true,
	},
	newThreadCreated: {
	email: true,
	},
	dailyDigest: {
	email: true,
	},
	weeklyDigest: {
	email: true,
	},
	},
	},
	};
	};

	const generateCommunity = () => {
	const name = faker.company.companyName();

	return {
	id: uuid(),
	createdAt: faker.date.past(2),
	name,
	description: casual.short_description(),
	website: faker.internet.url(),
	profilePhoto: faker.image.business(),
	coverPhoto: faker.image.image(),
	slug: slugify(name),
	};
	};

	const generateChannel = communityId => {
	const name = faker.commerce.department();

	return {
	id: uuid(),
	communityId,
	createdAt: faker.date.past(2),
	name,
	description: casual.short_description(),
	slug: slugify(name),
	isPrivate: faker.random.boolean(),
	isDefault: false,
	};
	};

	const generateUsersCommunities = (communityId, userId) => {
	const isOwner = faker.random.boolean();
	// for ease of use, set to false
	const isModerator = false;
	// if user is either an admin or moderator, they have to be a member
	// otherwise random chance
	const isMember = isOwner \|\| isModerator ? true : faker.random.boolean();
	// might be blocked as long as they aren't an admin, mod, or member
	const isBlocked =
	isOwner \|\| isModerator \|\| isMember ? false : faker.random.boolean();

	return {
	id: uuid(),
	createdAt: faker.date.past(2),
	communityId,
	userId,
	isOwner,
	isModerator,
	isMember,
	isBlocked,
	receiveNotifications: true,
	reputation: 1,
	};
	};

	const generateUsersChannels = (channels, usersCommunities, userId) => {
	// figure out which communities the user being evaulated is a member of
	let possibleCommunities = usersCommunities.filter(
	elem => elem.userId === userId
	);
	// make sure they are a member of the community
	possibleCommunities = possibleCommunities
	.filter(elem => elem.isMember \|\| elem.isOwner \|\| elem.isModerator)
	.map(elem => elem.communityId);
	let possibleChannels = channels.filter(
	channel => possibleCommunities.indexOf(channel.communityId) > -1
	);

	// for each of those communities, construct an array of channels that are in
	// that community
	// const possibleChannels = possibleCommunities.map(community => channels.filter(channel => channel.communityId === community.id))

	// for each of hte possible channels, generate a new usersChannels object
	const foo = possibleChannels.map(channel => {
	const isOwner = faker.random.boolean();
	// for ease of use, set to false
	const isModerator = false;
	// if user is either an admin or moderator, they have to be a member
	// otherwise random chance
	const isMember = isOwner \|\| isModerator ? true : faker.random.boolean();
	// if a user is admin, mod, or member, they can't be pending, otherwise random
	const isPending =
	isOwner \|\| isModerator \|\| isMember ? false : faker.random.boolean();
	// might be blocked as long as they aren't an admin, mod, pending, or member
	const isBlocked =
	isOwner \|\| isModerator \|\| isMember \|\| isPending
	? false
	: faker.random.boolean();

	return {
	id: uuid(),
	createdAt: new Date(),
	channelId: channel.id,
	userId,
	isOwner,
	isModerator,
	isMember,
	isBlocked,
	isPending,
	receiveNotifications: true,
	};
	});
	return foo;
	};

	const generateThread = (communityId, channelId, creatorId) => {
	const content = {
	title: casual.title(),
	body: JSON.stringify(toJSON(fromPlainText(casual.text()))),
	};

	const createdAt = faker.date.past(2);

	return {
	id: uuid(),
	createdAt,
	creatorId,
	channelId,
	communityId,
	isPublished: faker.random.boolean(),
	content,
	type: 'DRAFTJS',
	lastActive: faker.date.between(createdAt, new Date()),
	edits: [
	{
	timestamp: createdAt,
	content,
	},
	],
	modifiedAt: faker.date.between(createdAt, new Date()),
	};
	};

	const generateUsersThreads = (threadId, userId) => {
	const createdAt = faker.date.past(2);

	return {
	id: uuid(),
	createdAt,
	threadId,
	userId,
	isParticipant: true,
	receiveNotifications: true,
	};
	};

	const generateDirectMessageThread = users => {
	const createdAt = faker.date.past(2);
	const threadLastActive = faker.date.between(createdAt, faker.date.recent());

	return {
	id: uuid(),
	name: null,
	createdAt,
	threadLastActive,
	};
	};

	const generateUsersDirectMessageThreads = (threadId, userId) => {
	const createdAt = faker.date.past(2);
	const lastActive = faker.date.between(createdAt, faker.date.recent());
	const lastSeen = faker.date.between(createdAt, new Date());

	return {
	id: uuid(),
	createdAt,
	threadId,
	userId,
	lastActive,
	lastSeen,
	receiveNotifications: true,
	};
	};

	const generateMessage = (senderId, threadId, threadType) => {
	return {
	id: uuid(),
	threadType,
	threadId,
	senderId,
	content: {
	body: casual.text(),
	},
	messageType: 'text',
	timestamp: faker.date.past(2),
	};
	};

	const generateReaction = (userId, messageId) => {
	return {
	id: uuid(),
	messageId,
	userId,
	timestamp: faker.date.past(2),
	type: 'like',
	};
	};

	module.exports = {
	randomAmount,
	generateUser,
	generateUsersSettings,
	generateCommunity,
	generateChannel,
	generateUsersCommunities,
	generateUsersChannels,
	generateUsersDirectMessageThreads,
	generateThread,
	generateUsersThreads,
	generateMessage,
	generateReaction,
	generateDirectMessageThread,
	};