repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
amrtaher1234/Crypto-notifier-nest
|
src/shared/shared.module.ts
|
<filename>src/shared/shared.module.ts
import { CacheModule, Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { MailModule } from 'src/mail/mail.module';
import { Resource, ResourceSchema } from 'src/schemas/resource.schema';
import { User, UserSchema } from 'src/schemas/user.schema';
import { TasksService } from 'src/tasks/tasks.service';
import { FinanceService } from './finance/finance.service';
@Module({
imports: [
MailModule,
CacheModule.register(),
MongooseModule.forFeature([
{
name: User.name,
schema: UserSchema,
collection: 'users',
},
{
name: Resource.name,
schema: ResourceSchema,
collection: 'resources',
},
]),
],
providers: [TasksService, FinanceService],
exports: [MailModule, FinanceService],
})
export class SharedModule {}
|
amrtaher1234/Crypto-notifier-nest
|
src/user/user.service.ts
|
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User, UserDocument } from 'src/schemas/user.schema';
import { Quote } from 'yahoo-finance2/dist/esm/src/modules/quote';
import finance from 'yahoo-finance2';
import { CreateUserDto, CreateResourceDto } from './dtos/user.dto';
@Injectable()
export class UserService {
constructor(@InjectModel(User.name) private userModel: Model<UserDocument>) {}
async getSymbolData(symbol: string): Promise<Quote> {
return finance.quote(symbol);
}
async getAllUsers() {
return this.userModel.find().populate('resources.resource').lean().exec();
}
async createUser(createUser: CreateUserDto) {
return (
await this.userModel.create({
...createUser,
resources: createUser.resource || [],
})
).save();
}
async subscribeUser(id: string, createResource: CreateResourceDto) {
const pullPhase = await this.userModel.findByIdAndUpdate(id, {
$pull: {
resources: { resource: { $in: [createResource.resource] } },
},
});
const pushPhase = await this.userModel.findByIdAndUpdate(id, {
$push: {
resources: createResource,
},
});
await pullPhase.save();
await pushPhase.save();
}
}
|
amrtaher1234/Crypto-notifier-nest
|
src/tasks/tasks.service.ts
|
import { Injectable, Logger } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Cron, CronExpression } from '@nestjs/schedule';
import { Model } from 'mongoose';
import { SendResourceMailDto } from 'src/mail/mail.dto';
import { MailService } from 'src/mail/mail.service';
import { User, UserDocument } from 'src/schemas/user.schema';
import { FinanceService } from 'src/shared/finance/finance.service';
import { Quote } from 'yahoo-finance2/dist/esm/src/modules/quote';
@Injectable()
export class TasksService {
constructor(
@InjectModel(User.name) private userModel: Model<UserDocument>,
private finance: FinanceService,
private mailService: MailService,
) {}
private readonly logger = new Logger(TasksService.name);
@Cron(CronExpression.EVERY_11_HOURS)
handleCron() {
this.logger.debug('Called every 30 seconds');
this.handleUsersSubscriptions();
}
async handleUsersSubscriptions() {
let users = await this.userModel
.find()
.populate('resources.resource')
.lean()
.exec();
const mappedSymbolsQuotes = {};
users = users.filter((user) => user.resources && user.resources.length);
users.forEach((user) => {
if (user.resources && user.resources.length) {
user.resources.forEach(
(resource) =>
(mappedSymbolsQuotes[resource.resource.symbol] = resource),
);
}
});
const promises = [
...Object.keys(mappedSymbolsQuotes).map((k) =>
this.finance.getSymbolQuote(k),
),
];
const cryptoData = await Promise.all(promises);
const mappedUsers = {};
users.forEach((user) => {
cryptoData.forEach((quote) => {
if (this.isUserMatched(user, quote)) {
mappedUsers[user._id]
? mappedUsers[user._id].quotes.push(quote)
: (mappedUsers[user._id] = { user, quotes: [quote] });
return;
}
});
});
Object.keys(mappedUsers).forEach((key) => {
const data: { user: User; quotes: Quote[] } = mappedUsers[key];
this.sendUserMail(data.user, data.quotes);
});
}
async sendUserMail(user: User, quotes: Quote[]) {
const sendResourceMailDto: SendResourceMailDto = {
userEmail: user.email,
userName: user.name,
quotes,
};
this.mailService
.sendMailForResouce(sendResourceMailDto)
.then()
.catch((err) => console.log(err));
}
isUserMatched(user: User, quote: Quote) {
const currentPrice = quote.regularMarketPrice;
const resource = user.resources.find(
(resource) => resource.resource.symbol === quote.symbol,
);
if (!resource) {
return false;
}
const { min, max } = resource;
console.log(
currentPrice > min && currentPrice < max,
user.email,
user.resources[0].min,
currentPrice,
user.resources[0].max,
);
return !(currentPrice > min && currentPrice < max);
}
}
|
amrtaher1234/Crypto-notifier-nest
|
src/shared/finance/finance.service.ts
|
import { CACHE_MANAGER, Inject, Injectable } from '@nestjs/common';
import { Cache } from 'cache-manager';
import finance from 'yahoo-finance2';
import { Quote } from 'yahoo-finance2/dist/esm/src/modules/quote';
@Injectable()
export class FinanceService {
constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) {}
async getSymbolQuote(symbol: string) {
const cachedQuote = await this.cacheManager.get<Quote>(symbol);
if (cachedQuote) {
console.log('getting data from cache');
return cachedQuote;
} else {
return finance.quote(symbol).then((quote) => {
this.cacheManager.set(symbol, quote, { ttl: 10 });
return quote;
});
}
}
}
|
amrtaher1234/Crypto-notifier-nest
|
src/app.module.ts
|
<reponame>amrtaher1234/Crypto-notifier-nest
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { MongooseModule } from '@nestjs/mongoose';
import { ScheduleModule } from '@nestjs/schedule';
import { UserModule } from './user/user.module';
import { SharedModule } from './shared/shared.module';
@Module({
imports: [
UserModule,
ScheduleModule.forRoot(),
ConfigModule.forRoot({
isGlobal: true,
}),
MongooseModule.forRootAsync({
useFactory: async (config: ConfigService) => ({
uri: config.get('MONGO_URI'),
}),
inject: [ConfigService],
}),
SharedModule,
],
controllers: [],
providers: [],
})
export class AppModule {}
|
callmekungfu/seg3125-lab8
|
src/data/catelog.ts
|
<gh_stars>0
export type RentalLocation = 'Toronto' | 'Ottawa' | 'Montreal' | 'Vancouver';
export interface RentalItem {
name: string;
preview_image_url?: string;
slug: string;
description: {
short: string;
full?: string;
};
price_per_day: number;
available_locations: RentalLocation[];
category: string[];
loading: boolean;
}
export const VisionaryCatelog: RentalItem[] = [
{
name: 'Canon 5D mark III (Body Only)',
available_locations: ['Montreal', 'Ottawa', 'Toronto', 'Vancouver'],
category: ['photography', 'camera:dslr'],
description: {
short: 'Great versatile camera for all situations.',
},
price_per_day: 120,
preview_image_url: 'https://img.vistek.net/prodimg/large/261855.jpg',
loading: false,
slug: 'canon-5d-mark-iii',
},
];
|
callmekungfu/seg3125-lab8
|
src/App.tsx
|
import React, { useState } from 'react';
import { BrowserRouter as Router, Switch, Route, Link } from 'react-router-dom';
import { Layout, Menu, Button, Tooltip } from 'antd';
import { QuestionOutlined } from '@ant-design/icons';
import './App.css';
import ShopComponent from './components/Shop';
import OrderComponent from './components/Order';
import ChatComponent from './components/Chat';
const { Header, Content, Footer } = Layout;
function App() {
const [selectedMenu] = useState(window.location.pathname);
return (
<Router>
<Header>
<div className="logo" />
<Menu
theme="dark"
mode="horizontal"
defaultSelectedKeys={[selectedMenu]}
>
<Menu.Item key="/">
<Link to="/">Rental Store</Link>
</Menu.Item>
<Menu.Item key="/order">
<Link to="/order">Your Order</Link>
</Menu.Item>
</Menu>
</Header>
<Content>
<div className="site-layout-content">
<Switch>
<Route path="/order">
<OrderComponent />
</Route>
<Route path="/chat">
<ChatComponent />
</Route>
<Route path="/">
<ShopComponent />
</Route>
</Switch>
</div>
</Content>
<Footer style={{ textAlign: 'center' }}>Crafted by <NAME></Footer>
<div className="contact-us-container">
<Tooltip placement="left" title="Got a question? Contact us now!">
<Link to="/chat">
<Button
type="primary"
shape="circle"
title="contact us"
icon={<QuestionOutlined />}
size="large"
/>
</Link>
</Tooltip>
</div>
</Router>
);
}
export default App;
|
callmekungfu/seg3125-lab8
|
src/components/Shop.tsx
|
import React, { useState } from 'react';
import { Menu, Card, Col, Row, Input } from 'antd';
import { VisionaryCatelog } from '../data/catelog';
const { SubMenu } = Menu;
const { Meta } = Card;
const { Search } = Input;
const ShopComponent = () => {
const [current, setCurrent] = useState('all');
return (
<div className="store-wrapper">
<Menu
onClick={(e) => setCurrent(e.key.toString())}
selectedKeys={[current]}
mode="horizontal"
className="mb-30"
>
<Menu.Item key="all">Show All Products</Menu.Item>
<SubMenu title="Photography" key="photography">
<Menu.ItemGroup title="Camera">
<Menu.Item key="camera:dslr">DSLR Camera</Menu.Item>
<Menu.Item key="camera:mirrorless">Mirrorless Camera</Menu.Item>
<Menu.Item key="camera:action">Action Camera</Menu.Item>
</Menu.ItemGroup>
<Menu.ItemGroup title="Lens">
<Menu.Item key="lens:camera">Camera Lens</Menu.Item>
<Menu.Item key="lens:full">Full-frame Lens</Menu.Item>
</Menu.ItemGroup>
</SubMenu>
<SubMenu title="Videography" key="videography">
<Menu.Item key="camera:camcorder">Camcorder</Menu.Item>
<Menu.Item key="lens:camera">Camera Lens</Menu.Item>
</SubMenu>
<SubMenu title="Audio" key="audio">
<Menu.Item key="audio:mic">Microphone</Menu.Item>
<Menu.Item key="audio:mixer">Mixers</Menu.Item>
</SubMenu>
<SubMenu title="Lighting" key="lighting">
<Menu.Item key="light:studio">Studio Flash</Menu.Item>
<Menu.Item key="light:battery">Battery Flash</Menu.Item>
</SubMenu>
<SubMenu title="Support" key="support">
<Menu.Item key="support:tripod">Tripod</Menu.Item>
</SubMenu>
</Menu>
<Search
className="mb-30"
placeholder="Search through our large catelog here"
enterButton="Search"
size="large"
onSearch={(value) => console.log(value)}
/>
<Row gutter={[16, 16]}>
{VisionaryCatelog.map((item) => (
<Col xs={24} sm={12} md={8} lg={8} xl={4} key={item.name}>
<Card
hoverable
cover={
item.preview_image_url && (
<img alt={item.name} src={item.preview_image_url} />
)
}
>
<Meta
title={item.name}
description={`${
item.description.short
} Available in ${item.available_locations.join(', ')}`}
className="mb-15"
/>
<Meta title={`$${item.price_per_day.toFixed(2)}/day`} />
</Card>
</Col>
))}
</Row>
</div>
);
};
export default ShopComponent;
|
callmekungfu/seg3125-lab8
|
src/components/Order.tsx
|
<gh_stars>0
/* eslint-disable jsx-a11y/anchor-is-valid */
/* eslint-disable no-template-curly-in-string */
import React from 'react';
import {
Form,
Typography,
Input,
Row,
Col,
Button,
Select,
DatePicker,
Card,
List,
Skeleton,
Avatar,
} from 'antd';
import { VisionaryCatelog } from '../data/catelog';
const { Title } = Typography;
const { Option } = Select;
const { RangePicker } = DatePicker;
const { TextArea } = Input;
const formatter = new Intl.NumberFormat('en-US', {
style: 'currency',
currency: 'USD',
});
const validateMessages = {
required: '${label} is required!',
types: {
email: 'This is not validate email',
},
};
const OrderComponent = () => {
const [form] = Form.useForm();
return (
<div>
<Title level={2}>Rental Request Form</Title>
<p>
Your Request will be recieved by our Rental department staff who will
contact you by phone to confirm your rental. Our Rental team will be
able to answer questions regarding the equipment you are renting as well
as recommend compatible equipment choices.
</p>
<Row gutter={[30, 30]}>
<Col span={24}>
<Card title="Shopping Cart">
<List
className="demo-loadmore-list"
itemLayout="horizontal"
dataSource={VisionaryCatelog}
renderItem={(item) => (
<List.Item actions={[<Button type="link">Remove</Button>]}>
<Skeleton avatar title={false} loading={item.loading} active>
<List.Item.Meta
avatar={<Avatar src={item.preview_image_url} />}
title={<a href={`/item/${item.slug}`}>{item.name}</a>}
description={formatter.format(item.price_per_day)}
/>
</Skeleton>
</List.Item>
)}
/>
</Card>
</Col>
</Row>
<Form form={form} layout="vertical" validateMessages={validateMessages}>
<Row gutter={16}>
<Col span={8}>
<Form.Item
label="First Name"
name="first_name"
rules={[
{ required: true, message: 'Please provide your first name' },
]}
>
<Input placeholder="John" />
</Form.Item>
</Col>
<Col span={8}>
<Form.Item
label="Last Name"
name="last_name"
rules={[
{ required: true, message: 'Please provide your last name' },
]}
>
<Input placeholder="Smith" />
</Form.Item>
</Col>
<Col span={8}>
<Form.Item
label="Email Address"
name="email"
rules={[
{ required: true, message: 'Please provide your email' },
{ type: 'email' },
]}
>
<Input placeholder="<EMAIL>" />
</Form.Item>
</Col>
<Col span={8}>
<Form.Item
label="Phone number"
name="phone"
rules={[
{
required: true,
message: 'Please provide your phone number',
},
]}
>
<Input placeholder="XXX-XXX-XXXX" />
</Form.Item>
</Col>
<Col span={8}>
<Form.Item
label="Location"
name="location"
rules={[
{
required: true,
message: 'Please select a rental location',
},
]}
>
<Select placeholder="Rental Location">
<Option value="Montreal">Montreal</Option>
<Option value="Toronto">Toronto</Option>
<Option value="Ottawa">Ottawa</Option>
<Option value="Vancouver">Vancouver</Option>
</Select>
</Form.Item>
</Col>
<Col span={8}>
<Form.Item
name="date"
label="Rental Date"
rules={[
{
required: true,
message: 'Please select a rental date range',
},
]}
>
<RangePicker />
</Form.Item>
</Col>
<Col span={24}>
<Form.Item label="Special request" name="special_request">
<TextArea
placeholder="Anything you would like to include on your request (pick up time, additional accessories etc.)"
autoSize={{ minRows: 2 }}
/>
</Form.Item>
</Col>
</Row>
<Form.Item>
<Button type="primary" htmlType="submit">
Submit
</Button>
</Form.Item>
</Form>
</div>
);
};
export default OrderComponent;
|
callmekungfu/seg3125-lab8
|
src/components/Chat.tsx
|
<reponame>callmekungfu/seg3125-lab8
import React from 'react';
import { Comment, Avatar, Typography, Input, Button } from 'antd';
const { TextArea } = Input;
const ChatComponent = () => {
return (
<div className="chat-container">
<Typography.Title level={2}>Live Support</Typography.Title>
<div className="chat-comments">
<Comment
author={'<NAME> (Rental Staff)'}
avatar={
<Avatar
src="https://source.unsplash.com/DQPP9rVLYGQ/200x200"
alt="Jacob"
/>
}
content={<p>Hello Emma, how can I be of assistance today?</p>}
></Comment>
<Comment
author={'<NAME> (You)'}
avatar={
<Avatar
src="https://source.unsplash.com/AGy0SxTzqr8/200x200"
alt="Emma"
/>
}
content={
<p>
Hi Jacob! Just wondering if the Canon 5D mark iii is available
this weekend?
</p>
}
></Comment>
</div>
<div className="chat-response">
<Comment
avatar={
<Avatar
src="https://source.unsplash.com/AGy0SxTzqr8/200x200"
alt="Emma"
/>
}
content={
<div>
<TextArea
className="mb-15"
placeholder="Say something nice..."
autoSize={{ minRows: 2, maxRows: 4 }}
/>
<Button loading={false} type="primary">
Send
</Button>
</div>
}
></Comment>
</div>
</div>
);
};
export default ChatComponent;
|
ItzNesbroDev/ItzNesbro.js
|
index.ts
|
<filename>index.ts
export { ascii } from "./src/functions/ascii/ascii";
|
ItzNesbroDev/ItzNesbro.js
|
src/functions/ascii/ascii.ts
|
<filename>src/functions/ascii/ascii.ts
import figlet from "figlet";
interface IFiglet {
text: string;
channel: any;
}
/*
* @function ascii
* @param {IFiglet} figlet
* @returns {Promise<void>}
* @description This function will return a figlet ascii
* */
export const ascii = (props: IFiglet) => {
const { text, channel } = props;
if (text === "") throw new Error("ItzNesbro.js [FIGLET] - No text provided");
if (channel === "")
throw new Error("ItzNesbro.js [FIGLETA] - No channel provided");
if (text.length > 20) {
throw new Error("ItzNesbro.js [ERROR] - Text too long");
} else {
figlet(text, (err, data) => {
channel.send(data, {
code: "AsciiArt",
});
});
}
};
|
MoonG25/wangwang
|
src/cgv/entities/schedule.entity.ts
|
/**
* @todo ๋ฐ์์ค๋ ๋ฐ์ดํฐ๊ฐ ์ ๋ถ string ์ด๊ธฐ๋๋ฌธ์ ๋ณํ์ฒ๋ฆฌ ํ๊ธฐ
*/
export class Schedule {
id: number;
theaterCode: number;
thearerName: string;
movieIdx: number;
movieCode: number;
playStartTime: string; // hhmm
playEndTime: string; // hhmm
}
|
MoonG25/wangwang
|
src/cgv/dto/schedule-search.dto.ts
|
<gh_stars>0
import { IsString } from "class-validator";
import { RequestType, TheaterCode } from "../cgv.enum";
export class ScheduleSearchDto {
@IsString()
strId: string;
@IsString()
strMovieGroupCd: string;
@IsString()
strRequestType: RequestType;
@IsString()
strTheaterCd: TheaterCode;
}
|
MoonG25/wangwang
|
src/cgv/cgv.constants.ts
|
export const CGV_URL = 'http://m.cgv.co.kr/WebAPP/Reservation/Common';
export const SEPARATOR = '(^์ค^)';
// redis keys
export const COMING_SOON = 'COMING_SOON';
|
MoonG25/wangwang
|
src/cgv/dto/theater-schedule.dto.ts
|
import { IsString } from "class-validator";
import { RankType, RequestType, TheaterCode } from "../cgv.enum";
export class TheaterScheduleDto {
@IsString()
strMovieGroupCd: string;
@IsString()
strMovieTypeCd: string;
@IsString()
strPlayYMD: string;
@IsString()
strRankType: RankType;
@IsString()
strRequestType: RequestType;
@IsString()
strScreenTypeCd: string;
@IsString()
strTheaterCd: TheaterCode;
@IsString()
strUserID: string;
}
|
MoonG25/wangwang
|
src/utils/index.ts
|
export const getPlayYMD = () => {
const today = new Date();
const year = today.getFullYear();
const month = today.getMonth();
const day = today.getDate();
return `${year}${addZero(month)}${addZero(day)}`;
};
export const addZero = (value: number) => {
return ('0' + value).slice(-2);
};
|
MoonG25/wangwang
|
src/cgv/cgv.service.ts
|
<reponame>MoonG25/wangwang<filename>src/cgv/cgv.service.ts
import { HttpService } from '@nestjs/axios';
import { Injectable, Logger } from '@nestjs/common';
import { Cron } from '@nestjs/schedule';
import { find, map } from 'rxjs';
import { CacheService } from 'src/cache/cache.service';
import { CGV_URL, COMING_SOON, SEPARATOR } from './cgv.constants';
import { ScheduleSearchDto } from './dto/schedule-search.dto';
import { SearchDto } from './dto/search.dto';
import { TheaterScheduleDto } from './dto/theater-schedule.dto';
import {JSDOM} from 'jsdom';
/**
* @todo ๋ฐ์์จ ๋ฐ์ดํฐ๋ฅผ ๋ด์ ํด๋์ค ๋ง๋ค๊ธฐ
*/
@Injectable()
export class CgvService {
private readonly logger = new Logger(CgvService.name);
constructor(
private readonly httpService: HttpService,
private readonly cacheService: CacheService,
) {}
async getScheduleSearchKey(scheduleSearch: ScheduleSearchDto) {
const response = await this.httpService
.post(`${CGV_URL}/ajaxTheaterScheduleList.aspx/GetScheduleSearchKey`, scheduleSearch)
.pipe(map(res => res.data.d));
return response;
}
async getTheaterScheduleList(theaterSchedule: TheaterScheduleDto) {
const response = await this.httpService
.post(`${CGV_URL}/ajaxTheaterScheduleList.aspx/GetTheaterScheduleList`, theaterSchedule)
.pipe(map(res => res.data.d));
return response;
}
async getScheduleDayList(data: any) {
try {
const response = await this.httpService
.post(`${CGV_URL}/ajaxScheduleDayList.aspx/GetScheduleDayList`, data)
.pipe(map(res => res.data.d));
return response;
} catch (e) {
console.log(e);
return { error: e }
}
}
async getMiniMapData(data: any) {
try {
const response = await this.httpService
.post(`${CGV_URL}/ajaxMovieMiniMapData.aspx/GetMiniMapData`, data)
.pipe(map(res => res.data.d));
return response;
} catch (e) {
console.log(e);
return { error: e }
}
}
async findTicket(data: any) {
try {
const response = await this.getTheaterScheduleList(data);
// ๊ฒฐ๊ณผ๊ฐ์์ ํด๋น ์ํ ์ฐพ๊ธฐ
return response;
} catch (e) {
console.log(e);
return { error: e }
}
}
createKey(name: string, date: Date) {
return name + SEPARATOR + date;
}
pad(value: number) {
return ('0'+value).slice(-2)
}
now() {
const date = new Date();
const year = date.getFullYear();
const month = this.pad(date.getMonth() + 1);
const day = this.pad(date.getDate());
return `${year}${month}${day}`
}
async addSearch(search: SearchDto) {
const key = this.createKey(search.name, search.screenDate);
const storedData = await this.cacheService.get(key);
console.log('stored', storedData);
if (storedData) {
} else {
}
return await this.cacheService.set(key, {
...search,
createdAt: +new Date()
});
}
async getSearch(search: SearchDto) {
const key = this.createKey(search.name, search.screenDate);
return await this.cacheService.get(key);
}
async getSearchKeys() {
return await this.cacheService.keys();
}
@Cron('45 * * * * *')
async searching() {
/*
1. Redis์ ์ ์ฅ๋ ํค ๋ชฉ๋ก ์กฐํ
2. ํ์ฌ ์์์ค์ธ ๋ฐ์ดํฐ ์กฐํ
3. ์๋์ง ํ์ธ
4. ์์ผ๋ฉด Redis์์ ์ ๊ฑฐ ํ ๋ฉ์ธ์ง ์ ์ก
*/
const keys = await this.getSearchKeys();
console.log(keys);
this.logger.log('searching' + keys);
return keys;
}
async comingSoon() {
return await this.cacheService.get(COMING_SOON);
}
@Cron('0 0 * * * *')
async searchingComingSoon() {
try {
const response = await this.httpService
.get(`http://m.cgv.co.kr`)
.pipe(map(res => res.data))
.toPromise();
const { window: { document }} = new JSDOM(response);
const infoList = document.querySelectorAll(`
ul.cgvMovieChartContainer
> li:last-child
> ul.cgvMovieChartContents
> li:first-child
.movieInfo
`);
const result = Array.from(infoList).map((item: any) => {
const title = item.querySelector('p.cgbMovieTitle').textContent;
const image = item.querySelector('a > img').getAttribute('data-src').split('|')[1];
const dday = parseInt(item.querySelector('.movieDday').getAttribute('data-value'))
return {
title,
image,
dday
}
});
this.cacheService.set(COMING_SOON, result);
} catch (e) {
console.error(e);
}
}
}
|
MoonG25/wangwang
|
src/cgv/dto/search.dto.ts
|
<reponame>MoonG25/wangwang
import { IsDate, IsString } from "class-validator";
export class SearchDto {
@IsString()
name: string;
@IsDate()
screenDate: Date;
}
|
MoonG25/wangwang
|
src/cgv/cgv.module.ts
|
<reponame>MoonG25/wangwang<filename>src/cgv/cgv.module.ts
import { HttpModule } from '@nestjs/axios';
import { Module } from '@nestjs/common';
import { CacheModule } from 'src/cache/cache.module';
import { CgvController } from './cgv.controller';
import { CgvService } from './cgv.service';
@Module({
imports: [HttpModule, CacheModule],
controllers: [CgvController],
providers: [CgvService],
})
export class CgvModule {}
|
MoonG25/wangwang
|
src/cgv/cgv.controller.ts
|
import { Body, Controller, Get, Post, Query } from '@nestjs/common';
import { CgvService } from './cgv.service';
import { ScheduleSearchDto } from './dto/schedule-search.dto';
import { SearchDto } from './dto/search.dto';
import { TheaterScheduleDto } from './dto/theater-schedule.dto';
@Controller('cgv')
export class CgvController {
constructor(private readonly cgvService: CgvService) {}
@Post("search")
addSearch(@Body() search: SearchDto) {
return this.cgvService.addSearch(search);
}
@Get("search")
getSearch(@Query() search: SearchDto) {
return this.cgvService.getSearch(search);
}
@Get("search/keys")
getSearchKeys() {
return this.cgvService.getSearchKeys();
}
@Post('schedule/key')
getScheduleSearchKey(@Body() scheduleSearch: ScheduleSearchDto) {
return this.cgvService.getScheduleSearchKey(scheduleSearch);
}
@Post('schedule/day')
getScheduleDayList(@Body() data: any) {
return this.cgvService.getScheduleDayList(data);
}
@Post('schedule')
getTheaterScheduleList(@Body() theaterSchedule: TheaterScheduleDto) {
return this.cgvService.getTheaterScheduleList(theaterSchedule);
}
@Post('ticket')
findTicket(@Body() data: any) {
return this.cgvService.findTicket(data);
}
@Post('map')
getMiniMapData(@Body() data: any) {
return this.cgvService.getMiniMapData(data);
}
@Get('soon')
comingSoon() {
return this.cgvService.comingSoon();
}
@Get('store')
store() {
return this.cgvService.searchingComingSoon();
}
}
|
MoonG25/wangwang
|
src/cgv/cgv.enum.ts
|
export enum RequestType {
THEATER = "THEATER",
}
export enum TheaterCode {
YONGSAN = "0013",
WANGSIMNI = "0074",
YEONGDEUNGPO = "0059",
CHEONHO = "0199",
HONGDAE = "0191",
}
export enum RankType {
MOVIE = "MOVIE",
}
|
MoonG25/wangwang
|
src/cache/cache.module.ts
|
<gh_stars>0
import * as redisStore from 'cache-manager-redis-store';
import { CacheModule as BaseCacheModule, Module } from "@nestjs/common";
import { CacheService } from './cache.service';
// registerAsync๊ฐ ํ์ํ๊ฐ?
@Module({
imports: [
BaseCacheModule.register({
store: redisStore,
host: 'localhost',
port: 6379,
ttl: 604800,
}),
],
providers: [CacheService],
exports: [CacheService]
})
export class CacheModule {}
|
ideadapt/SAFE
|
tests/ts_tests/viewporter.d.ts
|
<reponame>ideadapt/SAFE<gh_stars>0
// Type definitions for Zynga Viewporter v2.1
// Project: https://github.com/zynga/viewporter
// Definitions by: <NAME> https://github.com/borisyankov
// Definitions: https://github.com/borisyankov/DefinitelyTyped
interface Viewporter {
preventPageScroll: boolean;
forceDetection: boolean;
ACTIVE: boolean;
READY: boolean;
isLandscape(): boolean;
ready(callback: EventListener): void;
change(callback: EventListener): void;
refresh(): void;
}
declare var viewporter: Viewporter;
|
ideadapt/SAFE
|
tests/ts_tests/linq.d.ts
|
<gh_stars>1-10
// Type definitions for linq.js 2.2
// Project: http://linqjs.codeplex.com/
// Definitions by: <NAME>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
// todo: jQuery plugin, RxJS Binding
declare module linq {
interface EnumerableStatic {
Choice(...contents: any[]): Enumerable;
Choice(contents: any[]): Enumerable;
Cycle(...contents: any[]): Enumerable;
Cycle(contents: any[]): Enumerable;
Empty(): Enumerable;
From(obj: any[]): Enumerable;
From(obj: any): Enumerable;
Return(element: any): Enumerable;
Matches(input: string, pattern: RegExp): Enumerable;
Matches(input: string, pattern: string, flags?: string): Enumerable;
Range(start: number, count: number, step?: number): Enumerable;
RangeDown(start: number, count: number, step?: number): Enumerable;
RangeTo(start: number, to: number, step?: number): Enumerable;
Repeat(obj: any, count?: number): Enumerable;
RepeatWithFinalize(initializer: () => any, finalizer: (resource: any) =>void ): Enumerable;
Generate(func: () => any, count?: number): Enumerable;
Generate(func: string, count?: number): Enumerable;
ToInfinity(start?: number, step?: number): Enumerable;
ToNegativeInfinity(start?: number, step?: number): Enumerable;
Unfold(seed, func: ($) => any): Enumerable;
Unfold(seed, func: string): Enumerable;
}
interface Enumerable {
//Projection and Filtering Methods
CascadeBreadthFirst(func: ($) => any[], resultSelector: (v, i: number) => any): Enumerable;
CascadeBreadthFirst(func: string, resultSelector: string): Enumerable;
CascadeDepthFirst(func: ($) => any[], resultSelector: (v, i: number) => any): Enumerable;
CascadeDepthFirst(func: string, resultSelector: string): Enumerable;
Flatten(...items: any[]): Enumerable;
Pairwise(selector: (prev, next) => any): Enumerable;
Pairwise(selector: string): Enumerable;
Scan(func: (a, b) => any): Enumerable;
Scan(func: string): Enumerable;
Scan(seed, func: (a, b) => any, resultSelector?: ($) => any): Enumerable;
Scan(seed, func: string, resultSelector?: string): Enumerable;
Select(selector: ($, i: number) => any): Enumerable;
Select(selector: string): Enumerable;
SelectMany(collectionSelector: ($, i: number) => any[], resultSelector?: ($, item) => any): Enumerable;
SelectMany(collectionSelector: ($, i: number) => Enumerable, resultSelector?: ($, item) => any): Enumerable;
SelectMany(collectionSelector: string, resultSelector?: string): Enumerable;
Where(predicate: ($, i: number) => boolean): Enumerable;
Where(predicate: string): Enumerable;
OfType(type: Function): Enumerable;
Zip(second: any[], selector: (v1, v2, i: number) => any): Enumerable;
Zip(second: any[], selector: string): Enumerable;
Zip(second: Enumerable, selector: (v1, v2, i: number) => any): Enumerable;
Zip(second: Enumerable, selector: string): Enumerable;
//Join Methods
Join(inner: any[], outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2) => any, compareSelector?: (v) => any): Enumerable;
Join(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
Join(inner: Enumerable, outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2) => any, compareSelector?: (v) => any): Enumerable;
Join(inner: Enumerable, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
GroupJoin(inner: any[], outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2: Enumerable) => any, compareSelector?: (v) => any): Enumerable;
GroupJoin(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
GroupJoin(inner: Enumerable, outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2: Enumerable) => any, compareSelector?: (v) => any): Enumerable;
GroupJoin(inner: Enumerable, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
//Set Methods
All(predicate: ($) => boolean): boolean;
All(predicate: string): boolean;
Any(predicate?: ($) => boolean): boolean;
Any(predicate?: string): boolean;
Concat(second: any[]): Enumerable;
Concat(second: Enumerable): Enumerable;
Insert(index: number, second: any[]): Enumerable;
Insert(index: number, second: Enumerable): Enumerable;
Alternate(value): Enumerable;
Contains(value, compareSelector?: ($) => any): boolean;
Contains(value, compareSelector?: string): boolean;
DefaultIfEmpty(defaultValue): Enumerable;
Distinct(compareSelector?: ($) => any): Enumerable;
Distinct(compareSelector?: string): Enumerable;
Except(second: any[], compareSelector?: ($) => any): Enumerable;
Except(second: any[], compareSelector?: string): Enumerable;
Except(second: Enumerable, compareSelector?: ($) => any): Enumerable;
Except(second: Enumerable, compareSelector?: string): Enumerable;
Intersect(second: any[], compareSelector?: ($) => any): Enumerable;
Intersect(second: any[], compareSelector?: string): Enumerable;
Intersect(second: Enumerable, compareSelector?: ($) => any): Enumerable;
Intersect(second: Enumerable, compareSelector?: string): Enumerable;
SequenceEqual(second: any[], compareSelector?: ($) => any): boolean;
SequenceEqual(second: any[], compareSelector?: string): boolean;
SequenceEqual(second: Enumerable, compareSelector?: ($) => any): boolean;
SequenceEqual(second: Enumerable, compareSelector?: string): boolean;
Union(second: any[], compareSelector?: ($) => any): Enumerable;
Union(second: any[], compareSelector?: string): Enumerable;
Union(second: Enumerable, compareSelector?: ($) => any): Enumerable;
Union(second: Enumerable, compareSelector?: string): Enumerable;
//Ordering Methods
OrderBy(keySelector?: ($) => any): OrderedEnumerable;
OrderBy(keySelector?: string): OrderedEnumerable;
OrderByDescending(keySelector?: ($) => any): OrderedEnumerable;
OrderByDescending(keySelector?: string): OrderedEnumerable;
Reverse(): Enumerable;
Shuffle(): Enumerable;
//Grouping Methods
GroupBy(keySelector: ($) => any, elementSelector?: ($) => any, resultSelector?: (key, e) => any, compareSelector?: ($) =>any): Enumerable;
GroupBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable;
PartitionBy(keySelector: ($) => any, elementSelector?: ($) => any, resultSelector?: (key, e) => any, compareSelector?: ($) =>any): Enumerable;
PartitionBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable;
BufferWithCount(count: number): Enumerable;
// Aggregate Methods
Aggregate(func: (a, b) => any);
Aggregate(seed, func: (a, b) => any, resultSelector?: ($) => any);
Aggregate(func: string);
Aggregate(seed, func: string, resultSelector?: string);
Average(selector?: ($) => number): number;
Average(selector?: string): number;
Count(predicate?: ($) => boolean): number;
Count(predicate?: string): number;
Max(selector?: ($) => number): number;
Max(selector?: string): number;
Min(selector?: ($) => number): number;
Min(selector?: string): number;
MaxBy(selector: ($) => number): any;
MaxBy(selector: string): any;
MinBy(selector: ($) => number): any;
MinBy(selector: string): any;
Sum(selector?: ($) => number): number;
Sum(selector?: string): number;
//Paging Methods
ElementAt(index: number): any;
ElementAtOrDefault(index: number, defaultValue): any;
First(predicate?: ($) => boolean): any;
First(predicate?: string): any;
FirstOrDefault(defaultValue, predicate?: ($) => boolean): any;
FirstOrDefault(defaultValue, predicate?: string): any;
Last(predicate?: ($) => boolean): any;
Last(predicate?: string): any;
LastOrDefault(defaultValue, predicate?: ($) => boolean): any;
LastOrDefault(defaultValue, predicate?: string): any;
Single(predicate?: ($) => boolean): any;
Single(predicate?: string): any;
SingleOrDefault(defaultValue, predicate?: ($) => boolean): any;
SingleOrDefault(defaultValue, predicate?: string): any;
Skip(count: number): Enumerable;
SkipWhile(predicate: ($, i: number) => boolean): Enumerable;
SkipWhile(predicate: string): Enumerable;
Take(count: number): Enumerable;
TakeWhile(predicate: ($, i: number) => boolean): Enumerable;
TakeWhile(predicate: string): Enumerable;
TakeExceptLast(count?: number): Enumerable;
TakeFromLast(count: number): Enumerable;
IndexOf(item): number;
LastIndexOf(item): number;
// Convert Methods
ToArray(): any[];
ToLookup(keySelector: ($) => any, elementSelector?: ($) => any, compareSelector?: (key) => any): Lookup;
ToLookup(keySelector: string, elementSelector?: string, compareSelector?: string): Lookup;
ToObject(keySelector: ($) => string, elementSelector: ($) => any): any;
ToObject(keySelector: string, elementSelector: string): any;
ToDictionary(keySelector: ($) => any, elementSelector: ($) => any, compareSelector?: (key) => any): Dictionary;
ToDictionary(keySelector: string, elementSelector: string, compareSelector?: string): Dictionary;
ToJSON(replacer?: (key, value) => any, space?: number): string;
ToJSON(replacer?: string, space?: number): string;
ToString(separator?: string, selector?: ($) =>any): string;
ToString(separator?: string, selector?: string): string;
//Action Methods
Do(action: ($, i: number) => void ): Enumerable;
Do(action: string): Enumerable;
ForEach(action: ($, i: number) => void ): void;
ForEach(func: ($, i: number) => boolean): void;
ForEach(action_func: string): void;
Write(separator?: string, selector?: ($) =>any): void;
Write(separator?: string, selector?: string): void;
WriteLine(selector?: ($) =>any): void;
Force(): void;
//Functional Methods
Let(func: (e: Enumerable) => Enumerable): Enumerable;
Share(): Enumerable;
MemoizeAll(): Enumerable;
//Error Handling Methods
Catch(handler: (error: Error) => void ): Enumerable;
Catch(handler: string): Enumerable;
Finally(finallyAction: () => void ): Enumerable;
Finally(finallyAction: string): Enumerable;
//For Debug Methods
Trace(message?: string, selector?: ($) =>any): Enumerable;
Trace(message?: string, selector?: string): Enumerable;
}
interface OrderedEnumerable extends Enumerable {
ThenBy(keySelector: ($) => any): OrderedEnumerable;
ThenBy(keySelector: string): OrderedEnumerable;
ThenByDescending(keySelector: ($) => any): OrderedEnumerable;
ThenByDescending(keySelector: string): OrderedEnumerable;
}
interface Grouping extends Enumerable {
Key();
}
interface Lookup {
Count(): number;
Get(key): Enumerable;
Contains(key): boolean;
ToEnumerable(): Enumerable;
}
interface Dictionary {
Add(key, value): void;
Get(key): any;
Set(key, value): boolean;
Contains(key): boolean;
Clear(): void;
Remove(key): void;
Count(): number;
ToEnumerable(): Enumerable;
}
}
declare var Enumerable: linq.EnumerableStatic;
|
ideadapt/SAFE
|
tests/ts_tests/breeze-1.0.d.ts
|
// Type definitions for Breeze 1.0
// Project: http://www.breezejs.com/
// Definitions by: <NAME> <https://github.com/borisyankov/>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
// Updated Jan 14 2011 - <NAME> (www.ideablade.com)
declare module BreezeCore {
interface ErrorCallback {
(error: Error): void;
}
interface IEnum {
contains(object: any): boolean;
fromName(name: string): EnumSymbol;
getNames(): string[];
getSymbols(): EnumSymbol[];
}
class Enum implements IEnum {
constructor (name: string, methodObj?: any);
addSymbol(propertiesObj?: any): EnumSymbol;
contains(object: any): boolean;
fromName(name: string): EnumSymbol;
getNames(): string[];
getSymbols(): EnumSymbol[];
static isSymbol(object: any): boolean;
seal(): void;
}
class EnumSymbol {
parentEnum: IEnum;
getName(): string;
toString(): string;
}
class Event {
constructor (name: string, publisher: any, defaultErrorCallback?: ErrorCallback);
static enable(eventName: string, target: any): void;
static enable(eventName: string, target: any, isEnabled: boolean): void;
static enable(eventName: string, target: any, isEnabled: Function): void;
static isEnabled(eventName: string, target: any): boolean;
publish(data: any, publishAsync?: boolean, errorCallback?: ErrorCallback): void;
publishAsync(data: any, errorCallback?: ErrorCallback): void;
subscribe(callback?: (data: any) => void ): number;
unsubscribe(unsubKey: number): boolean;
}
}
declare module Breeze {
interface Entity {
entityAspect: EntityAspect;
entityType: EntityType;
}
interface ComplexObject {
complexAspect: ComplexAspect;
complexType: ComplexType;
}
interface IProperty {
name: string;
parentEntityType: EntityType;
validators: Validator[];
isDataProperty: boolean;
isNavigationProperty: boolean;
}
interface IStructuralType {
complexProperties: DataProperty[];
dataProperties: DataProperty[];
name: string;
namespace: string;
shortName: string;
unmappedProperties: DataProperty[];
validators: Validator[];
}
class AutoGeneratedKeyType {
static Identity: AutoGeneratedKeyType;
static KeyGenerator: AutoGeneratedKeyType;
static None: AutoGeneratedKeyType;
}
class ComplexAspect {
complexObject: ComplexObject;
entityAspect: EntityAspect;
parent: Object;
parentProperty: DataProperty;
propertyPath: string;
originalValues: Object;
}
class ComplexType implements IStructuralType {
complexProperties: DataProperty[];
dataProperties: DataProperty[];
name: string;
namespace: string;
shortName: string;
unmappedProperties: DataProperty[];
validators: Validator[];
addProperty(dataProperty: DataProperty);
getProperties(): DataProperty[];
}
class DataProperty implements IProperty {
complexTypeName: string;
concurrencyMode: string;
dataType: DataTypeSymbol;
defaultValue: any;
fixedLength: boolean;
isComplexProperty: boolean;
isDataProperty: boolean;
isNavigationProperty: boolean;
isNullable: boolean;
isPartOfKey: boolean;
isUnmapped: boolean;
maxLength: number;
name: string;
nameOnServer: string;
parentEntityType: EntityType;
relatedNavigationProperty: NavigationProperty;
validators: Validator[];
constructor (config: DataPropertyOptions);
}
interface DataPropertyOptions {
complexTypeName?: string;
concurrencyMode?: string;
dataType?: DataTypeSymbol;
defaultValue?: any;
fixedLength?: boolean;
isNullable?: boolean;
isPartOfKey?: boolean;
isUnmapped?: boolean;
maxLength?: number;
name?: string;
nameOnServer?: string;
validators?: Validator[];
}
class DataService {
adapterName: string;
hasServerMetadata: boolean;
serviceName: string;
constructor(config: DataServiceOptions);
}
interface DataServiceOptions {
adapterName?: string;
hasServerMetadata?: boolean;
serviceName?: string;
}
class DataTypeSymbol extends BreezeCore.EnumSymbol {
defaultValue: any;
isNumeric: boolean;
}
interface DataType extends BreezeCore.IEnum {
Binary: DataTypeSymbol;
Boolean: DataTypeSymbol;
Byte: DataTypeSymbol;
DateTime: DataTypeSymbol;
Decimal: DataTypeSymbol;
Double: DataTypeSymbol;
Guid: DataTypeSymbol;
Int16: DataTypeSymbol;
Int32: DataTypeSymbol;
Int64: DataTypeSymbol;
Single: DataTypeSymbol;
String: DataTypeSymbol;
Time: DataTypeSymbol;
Undefined: DataTypeSymbol;
toDataType(typeName: string): DataTypeSymbol;
parseDateFromServer(date: any): Date;
}
var DataType: DataType;
class EntityActionSymbol extends BreezeCore.EnumSymbol {
}
interface EntityAction extends BreezeCore.IEnum {
AcceptChanges: EntityActionSymbol;
Attach: EntityActionSymbol;
AttachOnImport: EntityActionSymbol;
AttachOnQuery: EntityActionSymbol;
Clear: EntityActionSymbol;
Detach: EntityActionSymbol;
EntityStateChange: EntityActionSymbol;
MergeOnImport: EntityActionSymbol;
MergeOnSave: EntityActionSymbol;
MergeOnQuery: EntityActionSymbol;
PropertyChange: EntityActionSymbol;
RejectChanges: EntityActionSymbol;
}
var EntityAction: EntityAction;
class EntityAspect {
entity: Entity;
entityManager: EntityManager;
entityState: EntityStateSymbol;
isBeingSaved: boolean;
originalValues: any;
propertyChanged: PropertyChangedEvent;
validationErrorsChanged: ValidationErrorsChangedEvent;
acceptChanges(): void;
addValidationError(validationError: ValidationError): void;
clearValidationErrors(): void;
getKey(forceRefresh?: boolean): EntityKey;
getValidationErrors(): ValidationError[];
getValidationErrors(property: string): ValidationError[];
getValidationErrors(property: IProperty): ValidationError[];
loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): Promise;
loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): Promise;
rejectChanges(): void;
removeValidationError(validator: Validator): void;
removeValidationError(validator: Validator, property: DataProperty): void;
removeValidationError(validator: Validator, property: NavigationProperty): void;
setDeleted(): void;
setModified(): void;
setUnchanged(): void;
validateEntity(): boolean;
validateProperty(property: string, context?: any): boolean;
validateProperty(property: DataProperty, context?: any): boolean;
validateProperty(property: NavigationProperty, context?: any): boolean;
}
class PropertyChangedEventArgs {
entity: Entity;
propertyName: string;
oldValue: any;
newValue: any;
}
class PropertyChangedEvent extends BreezeCore.Event {
subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number;
}
class ValidationErrorsChangedEventArgs {
entity: Entity;
added: ValidationError[];
removed: ValidationError[];
}
class ValidationErrorsChangedEvent extends BreezeCore.Event {
subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number;
}
class EntityKey {
constructor (entityType: EntityType, keyValue: any);
constructor (entityType: EntityType, keyValues: any[]);
equals(entityKey: EntityKey): boolean;
static equals(k1: EntityKey, k2: EntityKey): boolean;
}
class EntityManager {
dataService: DataService;
keyGeneratorCtor: Function;
metadataStore: MetadataStore;
queryOptions: QueryOptions;
saveOptions: SaveOptions;
serviceName: string;
validationOptions: ValidationOptions;
entityChanged: EntityChangedEvent;
hasChangesChanged: BreezeCore.Event;
constructor (config?: EntityManagerOptions);
constructor (config?: string);
addEntity(entity: Entity): Entity;
attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity;
clear(): void;
createEmptyCopy(): EntityManager;
detachEntity(entity: Entity): boolean;
createEntity(entityTypeName: string, propertyInitializer: {}): Entity;
executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
executeQueryLocally(query: EntityQuery): Entity[];
exportEntities(entities?: Entity[]): string;
fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: boolean): Entity;
fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: boolean): Entity;
fetchEntityByKey(entityKey: EntityKey): Entity;
fetchMetadata(callback?: (schema: any) => void , errorCallback?: BreezeCore.ErrorCallback): Promise;
generateTempKeyValue(entity: Entity): any;
getChanges(): Entity[];
getChanges(entityTypeName: string): Entity[];
getChanges(entityTypeNames: string[]): Entity[];
getChanges(entityType: EntityType): Entity[];
getChanges(entityTypes: EntityType[]): Entity[];
getEntities(entityTypeName: string, entityState?: EntityStateSymbol): Entity[];
getEntities(entityTypeNames?: string[], entityState?: EntityStateSymbol): Entity[];
getEntities(entityTypeName?: string, entityStates?: EntityStateSymbol[]): Entity[];
getEntities(entityTypeNames?: string[], entityStates?: EntityStateSymbol[]): Entity[];
getEntities(entityType: EntityType, entityState?: EntityStateSymbol): Entity[];
getEntities(entityTypes?: EntityType[], entityState?: EntityStateSymbol): Entity[];
getEntities(entityType?: EntityType, entityStates?: EntityStateSymbol[]): Entity[];
getEntities(entityTypes?: EntityType[], entityStates?: EntityStateSymbol[]): Entity[];
getEntityByKey(typeName: string, keyValue: any): Entity;
getEntityByKey(typeName: string, keyValues: any[]): Entity;
getEntityByKey(entityKey: EntityKey): Entity;
hasChanges(): boolean;
hasChanges(entityTypeName: string): boolean;
hasChanges(entityTypeNames: string[]): boolean;
hasChanges(entityType: EntityType): boolean;
hasChanges(entityTypes: EntityType[]): boolean;
static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
rejectChanges(): Entity[];
saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Promise;
setProperties(config: EntityManagerProperties): void;
}
interface EntityManagerOptions {
serviceName?: string;
dataService?: DataService;
metadataStore?: MetadataStore;
queryOptions?: QueryOptions;
saveOptions?: SaveOptions;
validationOptions?: ValidationOptions;
keyGeneratorCtor?: Function;
}
interface EntityManagerProperties {
serviceName?: string;
dataService?: DataService;
queryOptions?: QueryOptions;
saveOptions?: SaveOptions;
validationOptions?: ValidationOptions;
keyGeneratorCtor?: Function;
}
interface ExecuteQuerySuccessCallback {
(data: { results: Entity[]; query: EntityQuery; XHR: XMLHttpRequest; }): void;
}
interface ExecuteQueryErrorCallback {
(error: { query: EntityQuery; XHR: XMLHttpRequest; }): void;
}
interface SaveChangesSuccessCallback {
(saveResult: { entities: Entity[]; keyMappings: any; XHR: XMLHttpRequest; }): void;
}
interface SaveChangesErrorCallback {
(error: { XHR: XMLHttpRequest; }): void;
}
class EntityChangedEventArgs {
entity: Entity;
entityAction: EntityActionSymbol;
args: Object;
}
class EntityChangedEvent extends BreezeCore.Event {
subscribe(callback?: (data: EntityChangedEventArgs) => void ): number;
}
class EntityQuery {
entityManager: EntityManager;
orderByClause: OrderByClause;
parameters: Object;
queryOptions: QueryOptions;
resourceName: string;
skipCount: number;
takeCount: number;
wherePredicate: Predicate;
constructor (resourceName?: string);
execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
executeLocally(): Entity[];
expand(propertyPaths: string[]): EntityQuery;
expand(propertyPaths: string): EntityQuery;
static from(resourceName: string): EntityQuery;
from(resourceName: string): EntityQuery;
static fromEntities(entity: Entity): EntityQuery;
static fromEntities(entities: Entity[]): EntityQuery;
static fromEntityKey(entityKey: EntityKey): EntityQuery;
static fromEntityNavigation(entity: Entity, navigationProperty: NavigationProperty): EntityQuery;
inlineCount(enabled?: boolean): EntityQuery;
orderBy(propertyPaths: string): EntityQuery;
orderBy(propertyPaths: string[]): EntityQuery;
orderByDesc(propertyPaths: string): EntityQuery;
orderByDesc(propertyPaths: string[]): EntityQuery;
select(propertyPaths: string): EntityQuery;
select(propertyPaths: string[]): EntityQuery;
skip(count: number): EntityQuery;
take(count: number): EntityQuery;
top(count: number): EntityQuery;
using(obj: EntityManager): EntityQuery;
using(obj: MergeStrategySymbol): EntityQuery;
using(obj: FetchStrategySymbol): EntityQuery;
where(predicate: Predicate): EntityQuery;
where(property: string, operator: string, value: any): EntityQuery;
where(property: string, operator: FilterQueryOpSymbol, value: any): EntityQuery;
where(predicate: FilterQueryOpSymbol): EntityQuery;
withParameters(params: Object): EntityQuery;
}
interface OrderByClause {
}
class EntityStateSymbol extends BreezeCore.EnumSymbol {
isAdded(): boolean;
isAddedModifiedOrDeleted(): boolean;
isDeleted(): boolean;
isDetached(): boolean;
isModified(): boolean;
isUnchanged(): boolean;
isUnchangedOrModified(): boolean;
}
interface EntityState extends BreezeCore.IEnum {
Added: EntityStateSymbol;
Deleted: EntityStateSymbol;
Detached: EntityStateSymbol;
Modified: EntityStateSymbol;
Unchanged: EntityStateSymbol;
}
var EntityState: EntityState;
class EntityType implements IStructuralType {
autoGeneratedKeyType: AutoGeneratedKeyType;
complexProperties: DataProperty[];
concurrencyProperties: DataProperty[];
dataProperties: DataProperty[];
defaultResourceName: string;
foreignKeyProperties: DataProperty[];
keyProperties: DataProperty[];
metadataStore: MetadataStore;
name: string;
namespace: string;
navigationProperties: NavigationProperty[];
shortName: string;
unmappedProperties: DataProperty[];
validators: Validator[];
constructor (config: MetadataStore);
constructor (config: EntityTypeOptions);
addProperty(property: IProperty): void;
addValidator(validator: Validator, property?: IProperty): void;
createEntity(initialValues?: Object): Entity;
getDataProperty(propertyName: string): DataProperty;
getEntityCtor(): Function;
getNavigationProperty(propertyName: string): NavigationProperty;
getProperties(): IProperty[];
getProperty(propertyPath: string, throwIfNotFound?: boolean): IProperty;
getPropertyNames(): string[];
setProperties(config: EntityTypeProperties): void;
toString(): string;
}
interface EntityTypeOptions {
shortName?: string;
namespace?: string;
autogeneratedKeyType?: AutoGeneratedKeyType;
defaultResourceName?: string;
}
interface EntityTypeProperties {
autogeneratedKeyType?: AutoGeneratedKeyType;
defaultResourceName?: string;
}
class FetchStrategySymbol extends BreezeCore.EnumSymbol {
}
interface FetchStrategy extends BreezeCore.IEnum {
FromLocalCache: FetchStrategySymbol;
FromServer: FetchStrategySymbol;
}
var FetchStrategy: FetchStrategy;
class FilterQueryOpSymbol extends BreezeCore.EnumSymbol {
}
interface FilterQueryOp extends BreezeCore.IEnum {
Contains: FilterQueryOpSymbol;
EndsWith: FilterQueryOpSymbol;
Equals: FilterQueryOpSymbol;
GreaterThan: FilterQueryOpSymbol;
GreaterThanOrEqual: FilterQueryOpSymbol;
LessThan: FilterQueryOpSymbol;
LessThanOrEqual: FilterQueryOpSymbol;
NotEquals: FilterQueryOpSymbol;
StartsWith: FilterQueryOpSymbol;
}
var FilterQueryOp: FilterQueryOp;
class LocalQueryComparisonOptions {
static caseInsensitiveSQL: LocalQueryComparisonOptions;
static defaultInstance: LocalQueryComparisonOptions;
constructor (config: { name?: string; isCaseSensitive?: boolean; usesSql92CompliantStringComparison?: boolean; });
setAsDefault(): void;
}
class MergeStrategySymbol extends BreezeCore.EnumSymbol {
}
interface MergeStrategy extends BreezeCore.IEnum {
OverwriteChanges: MergeStrategySymbol;
PreserveChanges: MergeStrategySymbol;
}
var MergeStrategy: MergeStrategy;
class MetadataStore {
namingConvention: NamingConvention;
constructor (config?: MetadataStoreOptions);
addDataService(dataService: DataService): void;
addEntityType(structuralType: IStructuralType): void;
exportMetadata(): string;
fetchMetadata(dataService: string, callback?: (data) => void , errorCallback?: BreezeCore.ErrorCallback): Promise;
fetchMetadata(dataService: DataService, callback?: (data) => void , errorCallback?: BreezeCore.ErrorCallback): Promise;
getDataService(serviceName: string): DataService;
getEntityType(entityTypeName: string, okIfNotFound?: boolean): IStructuralType;
getEntityTypes(): IStructuralType[];
hasMetadataFor(serviceName: string): boolean;
static importMetadata(exportedString: string): MetadataStore;
importMetadata(exportedString: string): MetadataStore;
isEmpty(): boolean;
registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void;
trackUnmappedType(entityCtor: Function, interceptor?: Function);
}
interface MetadataStoreOptions {
namingConvention?: NamingConvention;
localQueryComparisonOptions?: LocalQueryComparisonOptions;
}
class NamingConvention {
static camelCase: NamingConvention;
static defaultInstance: NamingConvention;
static none: NamingConvention;
constructor (config: NamingConventionOptions);
clientPropertyNameToServer(clientPropertyName: string): string;
clientPropertyNameToServer(clientPropertyName: string, property: IProperty): string;
serverPropertyNameToClient(serverPropertyName: string): string;
serverPropertyNameToClient(serverPropertyName: string, property: IProperty): string;
setAsDefault();
}
interface NamingConventionOptions {
serverPropertyNameToClient?: (name: string) => string;
clientPropertyNameToServer?: (name: string) => string;
}
class NavigationProperty implements IProperty {
associationName: string;
entityType: EntityType;
foreignKeyNames: string[];
inverse: NavigationProperty;
isDataProperty: boolean;
isNavigationProperty: boolean;
isScalar: boolean;
name: string;
parentEntityType: EntityType;
relatedDataProperties: DataProperty[];
validators: Validator[];
constructor (config: NavigationPropertyOptions);
}
interface NavigationPropertyOptions {
name?: string;
nameOnServer?: string;
entityTypeName: string;
isScalar?: boolean;
associationName?: string;
foreignKeyNames?: string[];
foreignKeyNamesOnServer?: string[];
validators?: Validator[];
}
class Predicate {
constructor (property: string, operator: string, value: any, valueIsLiteral?: boolean);
constructor (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean);
and: PredicateMethod;
static and: PredicateMethod;
static create: PredicateMethod;
static isPredicate(o: any): boolean;
static not(predicate: Predicate): Predicate;
not(): Predicate;
static or: PredicateMethod;
or: PredicateMethod;
toFunction(): Function;
toString(): string;
validate(entityType: EntityType): void;
}
interface PredicateMethod {
(predicates: Predicate[]): Predicate;
(...predicates: Predicate[]): Predicate;
(property: string, operator: string, value: any, valueIsLiteral?: boolean): Predicate;
(property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean): Predicate;
}
class Promise {
fail(errorCallback: Function): Promise;
fin(finallyCallback: Function): Promise;
then(callback: Function): Promise;
}
class QueryOptions {
static defaultInstance: QueryOptions;
fetchStrategy: FetchStrategySymbol;
mergeStrategy: MergeStrategySymbol;
constructor (config?: QueryOptionsConfiguration);
setAsDefault(): void;
using(config: QueryOptionsConfiguration): QueryOptions;
using(config: MergeStrategySymbol): QueryOptions;
using(config: FetchStrategySymbol): QueryOptions;
}
interface QueryOptionsConfiguration {
fetchStrategy?: FetchStrategySymbol;
mergeStrategy?: MergeStrategySymbol;
}
class SaveOptions {
allowConcurrentSaves: boolean;
static defaultInstance: SaveOptions;
constructor (config?: { allowConcurrentSaves?: boolean; });
setAsDefault(): SaveOptions;
}
class ValidationError {
context: any;
errorMessage: string;
property: IProperty;
propertyName: string;
validator: Validator;
constructor (validator: Validator, context: any, errorMessage: string);
}
class ValidationOptions {
static defaultInstance: ValidationOptions;
validateOnAttach: boolean;
validateOnPropertyChange: boolean;
validateOnQuery: boolean;
validateOnSave: boolean;
constructor (config?: ValidationOptionsConfiguration);
setAsDefault(): ValidationOptions;
using(config: ValidationOptionsConfiguration): ValidationOptions;
}
interface ValidationOptionsConfiguration {
validateOnAttach?: boolean;
validateOnSave?: boolean;
validateOnQuery?: boolean;
validateOnPropertyChange?: boolean;
}
class Validator {
static messageTemplates: any;
constructor (name: string, validatorFn: ValidatorFunction, context?: any);
static bool(): Validator;
static byte(): Validator;
static date(): Validator;
static duration(): Validator;
getMessage(): string;
static guid(): Validator;
static int16(): Validator;
static int32(): Validator;
static int64(): Validator;
static maxLength(context: { maxLength: number; }): Validator;
static number(): Validator;
static required(): Validator;
static string(): Validator;
static stringLength(context: { maxLength: number; minLength: number; }): Validator;
validate(value: any, context?: any): ValidationError;
}
interface ValidatorFunction {
(value: any, context: ValidatorFunctionContext): void;
}
interface ValidatorFunctionContext {
value: any;
validatorName: string;
displayName: string;
messageTemplate: string;
message?: string;
}
}
|
ideadapt/SAFE
|
tests/ts_tests/icheck.d.ts
|
<reponame>ideadapt/SAFE
// Type definitions for iCheck v0.8
// Project: http://damirfoy.com/iCheck/
// Definitions by: <NAME> https://github.com/qcz
// Definitions: https://github.com/borisyankov/DefinitelyTyped
interface ICheckOptions {
/**
* 'checkbox' or 'radio' to style only checkboxes or radio buttons, both by default
*/
handle?: string;
/**
* Base class added to customized checkboxes
*/
checkboxClass?: string;
/**
* Base class added to customized radio buttons
*/
radioClass?: string;
/**
* Class added on checked state (input.checked = true)
*/
checkedClass?: string;
/**
* If not empty, used instead of 'checkedClass' option (checkbox input specific)
*/
checkedCheckboxClass?: string;
/**
* If not empty, used instead of 'checkedClass' option (radio button input specific)
*/
checkedRadioClass?: string;
/**
* If not empty, added as class name on unchecked state (input.checked = false)
*/
uncheckedClass?: string;
/**
* If not empty, used instead of 'uncheckedClass' option (checkbox input specific)
*/
uncheckedCheckboxClass?: string;
/**
* If not empty, used instead of 'uncheckedClass' option (radio button input specific)
*/
uncheckedRadioClass?: string;
/**
* Class added on disabled state (input.disabled = true)
*/
disabledClass?: string;
/**
* If not empty, used instead of 'disabledClass' option (checkbox input specific)
*/
disabledCheckboxClass?: string;
/**
* If not empty, used instead of 'disabledClass' option (radio button input specific)
*/
disabledRadioClass?: string;
/**
* If not empty, added as class name on enabled state (input.disabled = false)
*/
enabledClass?: string;
/**
* If not empty, used instead of 'enabledClass' option (checkbox input specific)
*/
enabledCheckboxClass?: string;
/**
* If not empty, used instead of 'enabledClass' option (radio button input specific)
*/
enabledRadioClass?: string;
/**
* Class added on hover state (pointer is moved onto an input)
*/
hoverClass?: string;
/**
* Class added on focus state (input has gained focus)
*/
focusClass?: string;
/**
* Class added on active state (mouse button is pressed on an input)
*/
activeClass?: string;
/**
* Adds hoverClass to customized input on label hover and labelHoverClass to label on input hover
*/
labelHover?: boolean;
/**
* Class added to label if labelHover set to true
*/
labelHoverClass?: string;
/**
* Increase clickable area by given % (negative number to decrease)
*/
increaseArea?: string;
/**
* True to set 'pointer' CSS cursor over enabled inputs and 'default' over disabled
*/
cursor?: boolean;
/**
* Set true to inherit original input's class name
*/
inheritClass?: boolean;
/**
* If set to true, input's id is prefixed with 'iCheck-' and attached
*/
inheritID?: boolean;
/**
* Add HTML code or text inside customized input
*/
insert?: string;
}
interface JQuery {
iCheck(options?: ICheckOptions): JQuery;
iCheck(command: string, callback?: () => void): void;
}
|
ideadapt/SAFE
|
tests/ts_tests/hammerjs.d.ts
|
<gh_stars>0
// Type definitions for Hammer.js 1.0.5
// Project: http://eightmedia.github.com/hammer.js/
// Definitions by: <NAME> <https://github.com/borisyankov/>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
/// <reference path="../jquery/jquery.d.ts"/>
// Gesture Options : https://github.com/EightMedia/hammer.js/wiki/Getting-Started#gesture-options
interface HammerOptions {
drag?: boolean;
drag_block_horizontal?: boolean;
drag_block_vertical?: boolean;
drag_lock_to_axis?: boolean;
drag_max_touches?: number;
drag_min_distance?: number;
hold?: boolean;
hold_threshold?: number;
hold_timeout?: number;
prevent_default?: boolean;
prevent_mouseevents?: boolean;
release?: boolean;
show_touches?: boolean;
stop_browser_behavior?: any;
swipe?: boolean;
swipe_max_touches?: number;
swipe_velocity?: number;
tap?: boolean;
tap_always?: boolean;
tap_max_distance?: number;
tap_max_touchtime?: number;
doubletap_distance?: number;
doubletap_interval?: number;
touch?: boolean;
transform?: boolean;
transform_always_block?: boolean;
transform_min_rotation?: number;
transform_min_scale?: number;
}
interface HammerPoint {
x: number;
y: number;
}
interface HammerEvent {
originalEvent: Event;
position: HammerPoint;
touches: HammerPoint[];
}
interface HammertTransformEvent extends HammerEvent {
scale: number;
rotation: number;
}
interface HammerDirectionEvent extends HammerEvent {
angle: number;
direction: string;
distance: number;
distanceX: number;
distanceY: number;
}
declare class Hammer {
constructor (element: any, options?: HammerOptions);
ondragstart: (event: HammerDirectionEvent) => void;
ondrag: (event: HammerDirectionEvent) => void;
ondragend: (event: HammerDirectionEvent) => void;
onswipe: (event: HammerDirectionEvent) => void;
ontap: (event: HammerEvent) => void;
ondoubletap: (event: HammerEvent) => void;
onhold: (event: HammerEvent) => void;
ontransformstart: (event: HammertTransformEvent) => void;
ontransform: (event: HammertTransformEvent) => void;
ontransformend: (event: HammertTransformEvent) => void;
onrelease: (event: HammerEvent) => void;
}
interface JQuery {
hammer(options?: HammerOptions): JQuery;
}
|
ideadapt/SAFE
|
tests/ts_tests/jquery.validation.d.ts
|
// Type definitions for jquery.validation 1.11.1
// Project: http://bassistance.de/jquery-plugins/jquery-plugin-validation/
// Definitions by: https://github.com/fdecampredon
// Definitions: https://github.com/borisyankov/DefinitelyTyped
/// <reference path="../jquery/jquery.d.ts"/>
interface ValidationOptions
{
debug?: boolean;
errorClass?: string;
errorContainer?: string;
errorElement?: string;
errorLabelContainer?: string;
errorPlacement?: (error: JQuery, element: JQuery) => void;
focusCleanup?: boolean;
focusInvalid?: boolean;
groups?: Object;
highlight?: (element: HTMLElement, errorClass: string, validClass: string) => void;
ignore?: string;
ignoreTitle?: boolean;
invalidHandler?: (event: JQueryEventObject, validator: Validator) => void;
messages?: Object;
meta?: string;
onclick?: boolean;
onfocusout?: boolean;
onkeyup?: boolean;
onsubmit?: boolean;
rules?: Object;
showErrors?: (errorMap: Object, errorList: ErrorListItem[]) => void;
submitHandler?: (form: HTMLFormElement) => void;
success?: any;
unhighlight?: (element: HTMLElement, errorClass: string, validClass: string) => void;
validClass?: string;
wrapper?: string;
}
interface ErrorListItem
{
message: string;
element: HTMLElement;
}
interface Validator
{
addClassRules(name: string, rules: any): void;
addClassRules(rules: any): void;
addMethod(name: string, method: (value: any, element: any, ...params: any[]) => any, message?: any): void;
element(element: any): boolean;
form(): boolean;
format(template: string, ...arguments: string[]): string;
numberOfInvalids(): number;
resetForm(): void;
setDefaults(defaults: ValidationOptions): void;
settings: ValidationOptions;
showErrors(errors: any): void;
hideErrors(): void;
valid(): boolean;
size(): number;
errorMap: Object;
errorList: ErrorListItem[];
}
interface JQuery
{
removeAttrs(attributes: string): any;
rules(): any;
rules(methodName: string): any;
rules(methodName: string, rules: any): any;
valid(): boolean;
validate(options?: ValidationOptions): Validator;
}
interface JQueryStatic
{
format(template: string, ...arguments: string[]): string;
validator: Validator;
}
|
ideadapt/SAFE
|
tests/ts_tests/cheerio.d.ts
|
<reponame>ideadapt/SAFE
// Type definitions for Cheerio
// Project: https://github.com/MatthewMueller/cheerio
// Definitions by: <NAME> <https://github.com/blittle>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
interface Cheerio {
addClass(classNames: string): Cheerio;
hasClass(className: string): boolean;
removeClass(className?: any): Cheerio;
attr(attributeName: string, value: any): Cheerio;
attr(attributeName: string): string;
removeAttr(attributeName: any): Cheerio;
find(selector: string): Cheerio;
parent(): Cheerio;
next(): Cheerio;
prev(): Cheerio;
siblings(): Cheerio;
children(selector?: any): Cheerio;
each(func: (index: any, elem: any) => Cheerio);
map(callback: (index: any, domElement: Element) =>any): Cheerio;
filter(selector: string): Cheerio;
filter(func: (index: any) =>any): Cheerio;
first(): Cheerio;
last(): Cheerio;
eq(index: number): Cheerio;
append(...content: any[]): Cheerio;
prepend(...content: any[]): Cheerio;
after(...content: any[]): Cheerio;
before(...content: any[]): Cheerio;
remove(selector: string): Cheerio;
replaceWith(content: string): Cheerio;
empty(): Cheerio;
html(htmlString: string): Cheerio;
html(): string;
text(textString: string): Cheerio;
text(): string;
toArray(): any[];
clone() : Cheerio;
root() : Cheerio;
dom(): any;
contains(container: Element, contained: Element): boolean;
isArray(obj: any): boolean;
inArray(value: any, array: any[], fromIndex?: number): number;
merge(first: any[], second: any[]): any[];
}
interface CheerioOptionsInterface {
ignoreWhitespace?: boolean;
xmlMode?: boolean;
lowerCaseTags?: boolean;
}
interface CheerioStatic {
(...selectors: any[]): Cheerio;
(): Cheerio;
}
declare module "cheerio" {
export function load (html : string, options?: CheerioOptionsInterface) : CheerioStatic;
}
|
ideadapt/SAFE
|
tests/ts_tests/casperjs.d.ts
|
// Type definitions for CasperJS v1.0.0 API
// Project: http://casperjs.org/
// Definitions by: <NAME> <https://github.com/jedhunsaker>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
/// <reference path="../phantomjs/phantomjs.d.ts" />
interface CasperModule {
create(options: CasperOptions): Casper;
selectXPath(expression: string): Object
}
interface EventEmitter {
removeAllFilters(filter: string): Casper;
setFilter(filter: string, cb: Function): boolean;
}
interface Casper extends EventEmitter {
test: Tester;
constructor (options: CasperOptions): Casper;
// Properties
__utils__: ClientUtils;
// Methods
back(): Casper;
base64encode(url: string, method?: string, data?: any): string;
click(selector: string): boolean;
clickLabel(label: string, tag?: string): boolean;
capture(targetFilePath: string, clipRect: ClipRect): Casper;
captureBase64(format: string): string;
captureBase64(format: string, area: string): string;
captureBase64(format: string, area: ClipRect): string;
captureBase64(format: string, area: any): string;
captureSelector(targetFile: string, selector: string): Casper;
clear(): Casper;
debugHTML(selector?: string, outer?: boolean): Casper;
debugPage(): Casper;
die(message: string, status?: number): Casper;
download(url: string, target?: string, method?: string, data?: any): Casper;
each<T>(array: T[], fn: (self: Casper, item: T, index: number) => void): Casper;
echo(message: string, style?: string): Casper;
evaluate<T>(fn: () => T, ...args: any[]): T
evaluateOrDie(fn: () => any, message?: string, status?: number): Casper;
exit(status?: number): Casper;
exists(selector: string): boolean;
fetchText(selector: string): string;
forward(): Casper;
log(message: string, level?: string, space?: string): Casper;
fill(selector: string, values: any, submit?: boolean): void;
getCurrentUrl(): string;
getElementAttribute(selector: string, attribute: string): string;
getElementBounds(selector: string): ElementBounds;
getElementsBounds(selector: string): ElementBounds[];
getElementInfo(selector: string): ElementInfo;
getFormValues(selector: string): any;
getGlobal(name: string): any;
getHTML(selector?: string, outer?: boolean): string;
getPageContent(): string;
getTitle(): string;
mouseEvent(type: string, selector: string): boolean;
open(location: string, settings: OpenSettings): Casper;
reload(then?: (response: HttpResponse) => void): Casper;
repeat(times: number, then: Function): Casper;
resourceExists(test: Function): boolean;
resourceExists(test: string): boolean;
run(onComplete: Function, time?: number): Casper;
sendKeys(selector: string, keys: string, options?: any): Casper;
setHttpAuth(username: string, password: string): Casper;
start(url?: string, then?: (response: HttpResponse) => void): Casper;
status(asString: boolean): any;
then(fn: (self?: Casper) => void): Casper;
thenClick(selector: string): Casper;
thenEvaluate(fn: () => any, ...args: any[]): Casper;
thenOpen(location: string, then?: (response: HttpResponse) => void): Casper;
thenOpen(location: string, options?: OpenSettings, then?: (response: HttpResponse) => void): Casper;
thenOpenAndEvaluate(location: string, then?: Function, ...args: any[]): Casper;
toString(): string;
userAgent(agent: string): string;
viewport(width: number, height: number): Casper;
visible(selector: string): boolean;
wait(timeout: number, then?: Function): Casper;
waitFor(testFx: Function, then?: Function, onTimeout?: Function, timeout?: number): Casper;
waitForPopup(urlPattern: string, then?: Function, onTimeout?: Function, timeout?: number): Casper;
waitForPopup(urlPattern: RegExp, then?: Function, onTimeout?: Function, timeout?: number): Casper;
waitForSelector(selector: string, then?: Function, onTimeout?: Function, timeout?: number): Casper;
waitWhileSelector(selector: string, then?: Function, onTimeout?: Function, timeout?: number): Casper;
waitForResource(testFx: Function, then?: Function, onTimeout?: Function, timeout?: number): Casper;
waitForText(pattern: string, then?: Function, onTimeout?: Function, timeout?: number): Casper;
waitForText(pattern: RegExp, then?: Function, onTimeout?: Function, timeout?: number): Casper;
waitUntilVisible(selector: string, then?: Function, onTimeout?: Function, timeout?: number): Casper;
waitWhileVisible(selector: string, then?: Function, onTimeout?: Function, timeout?: number): Casper;
warn(message: string): Casper;
withFrame(frameInfo: string, then: Function): Casper;
withFrame(frameInfo: number, then: Function): Casper;
withPopup(popupInfo: string, step: Function): Casper;
withPopup(popupInfo: RegExp, step: Function): Casper;
zoom(factor: number): Casper;
}
interface HttpResponse {
contentType: string;
headers: any[];
id: number;
redirectURL: string;
stage: string;
status: number;
statusText: string;
time: string;
url: string;
}
interface OpenSettings {
method: string;
data: any;
headers: any;
}
interface ElementBounds {
top: number;
left: number;
width: number;
height: number;
}
interface ElementInfo {
nodeName: string;
attributes: any;
tag: string;
html: string;
text: string;
x: number;
y: number;
width: number;
height: number;
visible: boolean;
}
interface CasperOptions {
clientScripts?: any[];
exitOnError?: boolean;
httpStatusHandlers?: any;
logLevel?: string;
onAlert?: Function;
onDie?: Function;
onError?: Function;
onLoadError?: Function;
onPageInitialized?: Function;
onResourceReceived?: Function;
onResourceRequested?: Function;
onStepComplete?: Function;
onStepTimeout?: Function;
onTimeout?: Function;
onWaitTimeout?: Function;
page?: WebPage;
pageSettings?: any;
remoteScripts?: any[];
safeLogs?: boolean;
stepTimeout?: number;
timeout?: number;
verbose?: boolean;
viewportSize?: any;
waitTimeout?: number;
}
interface ClientUtils {
echo(message: string): void;
encode(contents: string): void;
exists(selector: string): void;
findAll(selector: string): void;
findOne(selector: string): void;
getBase64(url: string, method?: string, data?: any): void;
getBinary(url: string, method?: string, data?: any): void;
getDocumentHeight(): void;
getElementBounds(selector: string): void;
getElementsBounds(selector: string): void;
getElementByXPath(expression: string, scope?: HTMLElement): void;
getElementsByXPath(expression: string, scope?: HTMLElement): void;
getFieldValue(inputName: string): void;
getFormValues(selector: string): void;
mouseEvent(type: string, selector: string): void;
removeElementsByXPath(expression: string): void;
sendAJAX(url: string, method?: string, data?: any, async?: boolean): void;
visible(selector: string): void;
}
interface Colorizer {
colorize(text: string, styleName: string): void;
format(text: string, style: any): void;
}
interface Tester {
assert(condition: boolean, message?: string): any;
assertDoesntExist(selector: string, message?: string): any;
assertElementCount(selctor: string, expected: number, message?: string): any;
assertEquals(testValue: any, expected: any, message?: string): any;
assertEval(fn: Function, message: string, arguments: any): any;
assertEvalEquals(fn: Function, expected: any, message?: string, arguments?: any): any;
assertExists(selector: string, message?: string): any;
assertFalsy(subject: any, message?: string): any;
assertField(inputName: string, expected: string, message?: string): any;
assertHttpStatus(status: number, message?: string): any;
assertMatch(subject: any, pattern: RegExp, message?: string): any;
assertNot(subject: any, message?: string): any;
assertNotEquals(testValue: any, expected: any, message?: string): any;
assertNotVisible(selector: string, message?: string): any;
assertRaises(fn: Function, args: any[], message?: string): any;
assertSelectorDoesntHaveText(selector: string, text: string, message?: string): any;
assertSelectorExists(selector: string, message?: string): any;
assertSelectorHasText(selector: string, text: string, message?: string): any;
assertResourceExists(testFx: Function, message?: string): any;
assertTextExists(expected: string, message?: string): any;
assertTextDoesntExist(unexpected: string, message: string): any;
assertTitle(expected: string, message?: string): any;
assertTitleMatch(pattern: RegExp, message?: string): any;
assertTruthy(subject: any, message?: string): any;
assertType(input: any, type: string, message?: string): any;
assertUrlMatch(pattern: string, message?: string): any;
assertUrlMatch(pattern: RegExp, message?: string): any;
assertVisible(selector: string, message?: string): any;
/* since 1.1 */
begin(description: string, planned: number, suite: Function): any;
begin(description: string, suite: Function): any;
begin(description: string, planned: number, config: Object): any;
begin(description: string, config: Object): any;
colorize(message: string, style: string): any;
comment(message: string): any;
done(expected?: number): any;
error(message: string): any;
fail(message: string): any;
formatMessage(message: string, style: string): any;
getFailures(): Cases;
getPasses(): Cases;
info(message: string): any;
pass(message: string): any;
renderResults(exit: boolean, status: number, save: string): any;
}
interface Cases {
length: number;
cases: Case[];
}
interface Case {
success: boolean;
type: string;
standard: string;
file: string;
values: CaseValues;
}
interface CaseValues {
subject: boolean;
expected: boolean;
}
interface Utils {
betterTypeOf(input: any): any;
dump(value: any): any;
fileExt(file: string): any;
fillBlanks(text: string, pad: number): any;
format(f: string, ...args: any[]): any;
getPropertyPath(obj: any, path: string): any;
inherits(ctor: any, superCtor: any): any;
isArray(value: any): any;
isCasperObject(value: any): any;
isClipRect(value: any): any;
isFalsy(subject: any): any;
isFunction(value: any): any;
isJsFile(file: string): any;
isNull(value: any): any;
isNumber(value: any): any;
isObject(value: any): any;
isRegExp(value: any): any;
isString(value: any): any;
isTruthy(subject: any): any;
isType(what: any, type: string): any;
isUndefined(value: any): any;
isWebPage(what: any): any;
mergeObjects(origin: any, add: any): any;
node(name: string, attributes: any): any;
serialize(value: any): any;
unique(array: any[]): any;
}
|
HenryJMin/DCRefresher
|
src/utils/user.ts
|
<reponame>HenryJMin/DCRefresher
import * as ip from './ip'
import { modules } from '../core/modules'
const USERTYPE = {
UNFIXED: 0,
HALFFIXED: 1,
FIXED: 2,
SUBMANAGER: 3,
MANAGER: 4
}
const getType = (icon: string) => {
if (icon == '' || icon === undefined) {
return USERTYPE.UNFIXED
}
if (
icon.indexOf('/fix_nik.gif') > -1 ||
icon.indexOf('/dc20th_wgallcon4.') > -1
) {
return USERTYPE.FIXED
} else if (
icon.indexOf('/nik.gif') > -1 ||
icon.indexOf('/dc20th_wgallcon.') > -1
) {
return USERTYPE.HALFFIXED
} else if (
icon.indexOf('sub_manager') > -1 ||
icon.indexOf('/dc20th_wgallcon3.') > -1
) {
return USERTYPE.SUBMANAGER
} else if (
icon.indexOf('manager') > -1 ||
icon.indexOf('/dc20th_wgallcon2.') > -1
) {
return USERTYPE.MANAGER
}
return USERTYPE.UNFIXED
}
export class User {
nick: string
id: string | null
ip_data: string
icon: string | null
type: number
__ip: string | null
memo: refresherMemo | null
constructor (
nick: string,
id: string | null,
ip: string | null,
icon: string | null
) {
this.__ip = ''
this.ip_data = ''
this.nick = nick
this.id = id
this.ip = ip
this.icon = icon || ''
this.type = getType(this.icon)
this.memo = null
this.getMemo()
}
getMemo (): void {
const memos = modules.getData('์ ์ ์ ๋ณด', 'memos') as {
[index: string]: refresherMemo
}
if (!memos || typeof memos !== 'object') {
return
}
let memo: refresherMemo = {
text: '',
color: ''
}
if (this.id) {
memo = memos[`UID@${this.id}`]
}
if ((!memo || !memo.text) && this.ip) {
memo = memos[`IP@${this.ip}`]
}
if (!memo || !memo.text) {
memo = memos[`NICK@${this.nick}`]
}
this.memo = memo
}
import (dom: HTMLElement | null): this {
if (dom === null) {
return this
}
const nick = dom.dataset.nick || ''
const uid = dom.dataset.uid || ''
const ip = dom.dataset.ip || ''
let icon = ''
if (uid !== null) {
icon = (
(dom.querySelector('a.writer_nikcon img') as HTMLImageElement) || {}
).src
}
this.nick = nick
this.id = uid
this.ip = ip
this.icon = icon
this.type = getType(icon)
this.getMemo()
return this
}
isLogout (): boolean {
return this.ip !== null
}
isMember (): boolean {
return this.id !== null
}
set ip (v: string | null) {
if (v) {
this.ip_data = ip.format(ip.ISPData(v))
} else {
this.ip_data = ''
}
this.__ip = v || null
}
get ip (): string | null {
return this.__ip
}
}
|
alexgo-io/stacks.js
|
packages/network/src/index.ts
|
<gh_stars>1-10
import { TransactionVersion, ChainID, fetchPrivate } from '@stacks/common';
export const HIRO_MAINNET_DEFAULT = 'https://stacks-node-api.mainnet.stacks.co';
export const HIRO_TESTNET_DEFAULT = 'https://stacks-node-api.testnet.stacks.co';
export const HIRO_MOCKNET_DEFAULT = 'http://localhost:3999';
export interface NetworkConfig {
url: string;
}
export const StacksNetworks = ['mainnet', 'testnet'] as const;
export type StacksNetworkName = typeof StacksNetworks[number];
export class StacksNetwork {
version = TransactionVersion.Mainnet;
chainId = ChainID.Mainnet;
bnsLookupUrl = 'https://stacks-node-api.mainnet.stacks.co';
broadcastEndpoint = '/v2/transactions';
transferFeeEstimateEndpoint = '/v2/fees/transfer';
transactionFeeEstimateEndpoint = '/v2/fees/transaction';
accountEndpoint = '/v2/accounts';
contractAbiEndpoint = '/v2/contracts/interface';
readOnlyFunctionCallEndpoint = '/v2/contracts/call-read';
readonly coreApiUrl: string;
constructor(networkConfig: NetworkConfig) {
this.coreApiUrl = networkConfig.url;
}
static fromName = (networkName: StacksNetworkName): StacksNetwork => {
switch (networkName) {
case 'mainnet':
return new StacksMainnet();
case 'testnet':
return new StacksTestnet();
default:
throw new Error(
`Invalid network name provided. Must be one of the following: ${StacksNetworks.join(
', '
)}`
);
}
};
static fromNameOrNetwork = (network: StacksNetworkName | StacksNetwork) => {
if (typeof network !== 'string' && 'version' in network) {
return network;
}
return StacksNetwork.fromName(network);
};
isMainnet = () => this.version === TransactionVersion.Mainnet;
getBroadcastApiUrl = () => `${this.coreApiUrl}${this.broadcastEndpoint}`;
getTransferFeeEstimateApiUrl = () => `${this.coreApiUrl}${this.transferFeeEstimateEndpoint}`;
getTransactionFeeEstimateApiUrl = () =>
`${this.coreApiUrl}${this.transactionFeeEstimateEndpoint}`;
getAccountApiUrl = (address: string) =>
`${this.coreApiUrl}${this.accountEndpoint}/${address}?proof=0`;
getAbiApiUrl = (address: string, contract: string) =>
`${this.coreApiUrl}${this.contractAbiEndpoint}/${address}/${contract}`;
getReadOnlyFunctionCallApiUrl = (
contractAddress: string,
contractName: string,
functionName: string
) =>
`${this.coreApiUrl}${
this.readOnlyFunctionCallEndpoint
}/${contractAddress}/${contractName}/${encodeURIComponent(functionName)}`;
getInfoUrl = () => `${this.coreApiUrl}/v2/info`;
getBlockTimeInfoUrl = () => `${this.coreApiUrl}/extended/v1/info/network_block_times`;
getPoxInfoUrl = () => `${this.coreApiUrl}/v2/pox`;
getRewardsUrl = (address: string, options?: any) => {
let url = `${this.coreApiUrl}/extended/v1/burnchain/rewards/${address}`;
if (options) {
url = `${url}?limit=${options.limit}&offset=${options.offset}`;
}
return url;
};
getRewardsTotalUrl = (address: string) =>
`${this.coreApiUrl}/extended/v1/burnchain/rewards/${address}/total`;
getRewardHoldersUrl = (address: string, options?: any) => {
let url = `${this.coreApiUrl}/extended/v1/burnchain/reward_slot_holders/${address}`;
if (options) {
url = `${url}?limit=${options.limit}&offset=${options.offset}`;
}
return url;
};
getStackerInfoUrl = (contractAddress: string, contractName: string) =>
`${this.coreApiUrl}${this.readOnlyFunctionCallEndpoint}
${contractAddress}/${contractName}/get-stacker-info`;
getNameInfo(fullyQualifiedName: string) {
/*
TODO: Update to v2 API URL for name lookups
*/
const nameLookupURL = `${this.bnsLookupUrl}/v1/names/${fullyQualifiedName}`;
return fetchPrivate(nameLookupURL)
.then(resp => {
if (resp.status === 404) {
throw new Error('Name not found');
} else if (resp.status !== 200) {
throw new Error(`Bad response status: ${resp.status}`);
} else {
return resp.json();
}
})
.then(nameInfo => {
// the returned address _should_ be in the correct network ---
// blockstackd gets into trouble because it tries to coerce back to mainnet
// and the regtest transaction generation libraries want to use testnet addresses
if (nameInfo.address) {
return Object.assign({}, nameInfo, { address: nameInfo.address });
} else {
return nameInfo;
}
});
}
}
export class StacksMainnet extends StacksNetwork {
version = TransactionVersion.Mainnet;
chainId = ChainID.Mainnet;
constructor(networkUrl: NetworkConfig = { url: HIRO_MAINNET_DEFAULT }) {
super(networkUrl);
}
}
export class StacksTestnet extends StacksNetwork {
version = TransactionVersion.Testnet;
chainId = ChainID.Testnet;
constructor(networkUrl: NetworkConfig = { url: HIRO_TESTNET_DEFAULT }) {
super(networkUrl);
}
}
export class StacksMocknet extends StacksNetwork {
version = TransactionVersion.Testnet;
chainId = ChainID.Testnet;
constructor(networkUrl: NetworkConfig = { url: HIRO_MOCKNET_DEFAULT }) {
super(networkUrl);
}
}
|
alexgo-io/stacks.js
|
packages/profile/src/profile.ts
|
import { signProfileToken, extractProfile } from './profileTokens';
import { getPersonFromLegacyFormat } from './profileSchemas';
import {
getName,
getFamilyName,
getGivenName,
getAvatarUrl,
getDescription,
getVerifiedAccounts,
getAddress,
getBirthDate,
getConnections,
getOrganizations,
} from './profileSchemas/personUtils';
// TODO: bring into this monorepo/convert to ts
// @ts-ignore
import { makeZoneFile, parseZoneFile } from 'zone-file';
// Could not find a declaration file for module
// @ts-ignore
import * as inspector from 'schema-inspector';
import { Logger, fetchPrivate } from '@stacks/common';
const schemaDefinition: { [key: string]: any } = {
type: 'object',
properties: {
'@context': { type: 'string', optional: true },
'@type': { type: 'string' },
},
};
/**
* Represents a user profile
*
*/
export class Profile {
_profile: { [key: string]: any };
constructor(profile = {}) {
this._profile = Object.assign(
{},
{
'@context': 'http://schema.org/',
},
profile
);
}
toJSON() {
return Object.assign({}, this._profile);
}
toToken(privateKey: string): string {
return signProfileToken(this.toJSON(), privateKey);
}
static validateSchema(profile: any, strict = false): any {
schemaDefinition.strict = strict;
return inspector.validate(schemaDefinition, profile);
}
static fromToken(token: string, publicKeyOrAddress: string | null = null): Profile {
const profile = extractProfile(token, publicKeyOrAddress);
return new Profile(profile);
}
static makeZoneFile(domainName: string, tokenFileURL: string): string {
return makeProfileZoneFile(domainName, tokenFileURL);
}
}
const personSchemaDefinition = {
type: 'object',
strict: false,
properties: {
'@context': { type: 'string', optional: true },
'@type': { type: 'string' },
'@id': { type: 'string', optional: true },
name: { type: 'string', optional: true },
givenName: { type: 'string', optional: true },
familyName: { type: 'string', optional: true },
description: { type: 'string', optional: true },
image: {
type: 'array',
optional: true,
items: {
type: 'object',
properties: {
'@type': { type: 'string' },
name: { type: 'string', optional: true },
contentUrl: { type: 'string', optional: true },
},
},
},
website: {
type: 'array',
optional: true,
items: {
type: 'object',
properties: {
'@type': { type: 'string' },
url: { type: 'string', optional: true },
},
},
},
account: {
type: 'array',
optional: true,
items: {
type: 'object',
properties: {
'@type': { type: 'string' },
service: { type: 'string', optional: true },
identifier: { type: 'string', optional: true },
proofType: { type: 'string', optional: true },
proofUrl: { type: 'string', optional: true },
proofMessage: { type: 'string', optional: true },
proofSignature: { type: 'string', optional: true },
},
},
},
worksFor: {
type: 'array',
optional: true,
items: {
type: 'object',
properties: {
'@type': { type: 'string' },
'@id': { type: 'string', optional: true },
},
},
},
knows: {
type: 'array',
optional: true,
items: {
type: 'object',
properties: {
'@type': { type: 'string' },
'@id': { type: 'string', optional: true },
},
},
},
address: {
type: 'object',
optional: true,
properties: {
'@type': { type: 'string' },
streetAddress: { type: 'string', optional: true },
addressLocality: { type: 'string', optional: true },
postalCode: { type: 'string', optional: true },
addressCountry: { type: 'string', optional: true },
},
},
birthDate: { type: 'string', optional: true },
taxID: { type: 'string', optional: true },
},
};
/**
* @ignore
*/
export class Person extends Profile {
constructor(profile = {}) {
super(profile);
this._profile = Object.assign(
{},
{
'@type': 'Person',
},
this._profile
);
}
static validateSchema(profile: any, strict = false) {
personSchemaDefinition.strict = strict;
return inspector.validate(schemaDefinition, profile);
}
static fromToken(token: string, publicKeyOrAddress: string | null = null): Person {
const profile = extractProfile(token, publicKeyOrAddress);
return new Person(profile);
}
static fromLegacyFormat(legacyProfile: any) {
const profile = getPersonFromLegacyFormat(legacyProfile);
return new Person(profile);
}
toJSON() {
return {
profile: this.profile(),
name: this.name(),
givenName: this.givenName(),
familyName: this.familyName(),
description: this.description(),
avatarUrl: this.avatarUrl(),
verifiedAccounts: this.verifiedAccounts(),
address: this.address(),
birthDate: this.birthDate(),
connections: this.connections(),
organizations: this.organizations(),
};
}
profile() {
return Object.assign({}, this._profile);
}
name() {
return getName(this.profile());
}
givenName() {
return getGivenName(this.profile());
}
familyName() {
return getFamilyName(this.profile());
}
description() {
return getDescription(this.profile());
}
avatarUrl() {
return getAvatarUrl(this.profile());
}
verifiedAccounts(verifications?: any[]) {
return getVerifiedAccounts(this.profile(), verifications);
}
address() {
return getAddress(this.profile());
}
birthDate() {
return getBirthDate(this.profile());
}
connections() {
return getConnections(this.profile());
}
organizations() {
return getOrganizations(this.profile());
}
}
/**
*
* @param origin
* @param tokenFileUrl
*
* @ignore
*/
export function makeProfileZoneFile(origin: string, tokenFileUrl: string): string {
if (!tokenFileUrl.includes('://')) {
throw new Error('Invalid token file url');
}
const urlScheme = tokenFileUrl.split('://')[0];
const urlParts = tokenFileUrl.split('://')[1].split('/');
const domain = urlParts[0];
const pathname = `/${urlParts.slice(1).join('/')}`;
const zoneFile = {
$origin: origin,
$ttl: 3600,
uri: [
{
name: '_http._tcp',
priority: 10,
weight: 1,
target: `${urlScheme}://${domain}${pathname}`,
},
],
};
const zoneFileTemplate = '{$origin}\n{$ttl}\n{uri}\n';
return makeZoneFile(zoneFile, zoneFileTemplate);
}
/**
*
* @param zoneFileJson
*
* @ignore
*/
export function getTokenFileUrl(zoneFileJson: any): string | null {
if (!zoneFileJson.hasOwnProperty('uri')) {
return null;
}
if (!Array.isArray(zoneFileJson.uri)) {
return null;
}
if (zoneFileJson.uri.length < 1) {
return null;
}
const validRecords = zoneFileJson.uri.filter(
(record: any) => record.hasOwnProperty('target') && record.name === '_http._tcp'
);
if (validRecords.length < 1) {
return null;
}
const firstValidRecord = validRecords[0];
if (!firstValidRecord.hasOwnProperty('target')) {
return null;
}
let tokenFileUrl = firstValidRecord.target;
if (tokenFileUrl.startsWith('https')) {
// pass
} else if (tokenFileUrl.startsWith('http')) {
// pass
} else {
tokenFileUrl = `https://${tokenFileUrl}`;
}
return tokenFileUrl;
}
/**
*
* @param zoneFile
* @param publicKeyOrAddress
*
* @ignore
*/
export function resolveZoneFileToProfile(
zoneFile: any,
publicKeyOrAddress: string
): Promise<Record<string, any>> {
return new Promise((resolve, reject) => {
let zoneFileJson = null;
try {
zoneFileJson = parseZoneFile(zoneFile);
if (!zoneFileJson.hasOwnProperty('$origin')) {
zoneFileJson = null;
}
} catch (e) {
reject(e);
}
let tokenFileUrl: string | null = null;
if (zoneFileJson && Object.keys(zoneFileJson).length > 0) {
tokenFileUrl = getTokenFileUrl(zoneFileJson);
} else {
try {
return resolve(Person.fromLegacyFormat(JSON.parse(zoneFile)).profile());
} catch (error) {
return reject(error);
}
}
if (tokenFileUrl) {
fetchPrivate(tokenFileUrl)
.then(response => response.text())
.then(responseText => JSON.parse(responseText))
.then(responseJson => {
const tokenRecords = responseJson;
const profile = extractProfile(tokenRecords[0].token, publicKeyOrAddress);
resolve(profile);
})
.catch(error => {
Logger.error(
`resolveZoneFileToProfile: error fetching token file ${tokenFileUrl}: ${error}`
);
reject(error);
});
} else {
Logger.debug('Token file url not found. Resolving to blank profile.');
resolve({});
}
});
}
|
anthonyamaro15/typescript-fundamentals
|
src/App.tsx
|
interface DataTypes<T> {
data: T;
}
interface GenericIdentityFn<Type> {
<Type>(arg: Type): Type;
}
// here we basically define the type of the function
let myIdentity: GenericIdentityFn<number> = defineType;
// we can now pass anything to it
function defineType<T>(arg: T): T {
return arg;
}
// you can also explicity define de type
const string = defineType<string>("hello");
const number = defineType(3);
// working with arrays as parameters should be the same but instead of passing only the T type it should be T[]
function loggingIdentity<T>(arg: T[]): T[] {
// since we define parameter as T[] it knows its an array so we have the array methods.
console.log(arg.length);
return arg;
}
const strValues: DataTypes<string> = {
data: "name",
};
const arrayValues: DataTypes<string[]> = {
data: ["name", "age"],
};
// think of this as a function and T is a parameter, so it can be anything but when actually calling the ResultTypes you have to pass the Type
interface ResultTypes<T> {
name?: string;
lastName?: string;
age?: number;
info?: T;
}
// Example here i want the type of info to be a string
const resultStr: ResultTypes<string> = {
name: "anthony",
lastName: "amaro",
age: 26,
info: "",
};
const resultNum: ResultTypes<number> = {
name: "anthony",
lastName: "amaro",
age: 26,
info: 0,
};
function defineObj<T>(): ResultTypes<string> {
const result: ResultTypes<string> = {
name: "anthony",
lastName: "amaro",
age: 26,
info: "",
};
return result;
}
function App() {
return (
<div className="App">
<h1>TypeScript Basics</h1>
</div>
);
}
export default App;
|
avbdev/siksha
|
client/src/utils/endpoints/PostEndPoints.ts
|
<filename>client/src/utils/endpoints/PostEndPoints.ts
export enum PostEndPoint {
x = "",
}
|
avbdev/siksha
|
client/src/utils/endpoints/PatchEndPoints.ts
|
<filename>client/src/utils/endpoints/PatchEndPoints.ts
export enum PatchEndPoint {}
|
avbdev/siksha
|
client/src/components/atoms/Table/index.tsx
|
<gh_stars>0
import React, { useEffect, useMemo, useState } from "react";
import { apps } from "../../../mock/mock";
export interface IApps {
AppName: string;
AppId: string;
Owner: string;
UsersCount: number;
__Id?: any;
}
interface ITableHeader {
displayName: string;
ariaLabel: string;
}
interface CustomTabHeader extends ITableHeader {
appName: string;
appId: string;
owner: string;
uniqueUsers: string;
}
interface ITableRows {
data: CustomTabHeader[];
}
interface ITable {
headers: ITableHeader[];
rows: ITableRows[];
}
// export const Table: React.FC<ITable> = ({ headers, rows }) => {
export const Table: React.FC = () => {
const [updatedApps, setUpdatedApps] = useState<IApps[]>();
const [appName, setAppName] = useState<string>();
const [appId, setAppId] = useState<string>();
const [appOwner, setAppOwner] = useState<string>();
const upApps = React.useMemo(() => {
return apps;
}, [apps]);
// useMemo(())
useEffect(() => {
setUpdatedApps(apps);
}, [upApps]);
const handleAppNameFilter = (data?: any, data2?: any) => {
const filteredApps = upApps.filter((item) =>
item.AppName.toLowerCase().includes(data.target.value.toLowerCase())
);
setAppName(data.target.value);
setUpdatedApps(filteredApps);
};
const handleAppIdFilter = (data?: any, data2?: any) => {
const filteredApps = upApps.filter((item) =>
item.AppId.toLowerCase().includes(data.target.value.toLowerCase())
);
setAppId(data.target.value);
setUpdatedApps(filteredApps);
};
const handleAppOwnerFilter = (data?: any, data2?: any) => {
const filteredApps = upApps.filter((item) =>
item.Owner.toLowerCase().includes(data.target.value.toLowerCase())
);
setAppOwner(data.target.value);
setUpdatedApps(filteredApps);
};
useEffect(() => {
// console.log("Data", appName);
}, [appName]);
return (
<div style={{ overflow: "auto", width: "100%" }}>
<div>
Filter by <br />
<>
<label>AppName: </label>
<input
type="text"
name="App Name"
value={appName}
onChange={handleAppNameFilter}
/>
</>
<>
<label>AppId: </label>
<input
type="text"
name="AppId"
value={appId}
onChange={handleAppIdFilter}
/>
</>
<>
<label>Owner: </label>
<input
type="text"
name="AppOwner"
value={appOwner}
onChange={handleAppOwnerFilter}
/>
</>
</div>
<table>
<thead>
<tr>
<th>App Name</th>
<th>App Id</th>
<th>Owner Alias</th>
<th>Users Count</th>
</tr>
</thead>
<tbody>
{updatedApps &&
updatedApps.length > 0 &&
updatedApps.map((data, index) => {
return (
<tr key={index}>
<td>{data.AppName}</td>
<td>{data.AppId}</td>
<td>{data.Owner}</td>
<td>{data.UsersCount}</td>
</tr>
);
})}
</tbody>
</table>
</div>
);
};
// <Table rows={rows} headers={headers} onClick={onClick} />
|
avbdev/siksha
|
client/src/components/atoms/Table/TableBody.tsx
|
import React from "react";
import { isPrimitive, ObjectValues } from "./Utils";
export interface IRenderBodyProps {
// headerProps?: any;
// headerContainerProps?: any;
items?: any[];
}
export const RenderBody: React.FC<IRenderBodyProps> = (props) => {
const { items } = props;
return (
<tbody>
{items &&
items.map((item: any, index: number) => {
return (
<tr>
{ObjectValues(item).map((entry) => (
<td>{isPrimitive(entry) ? entry : ""}</td>
))}
</tr>
);
})}
</tbody>
);
};
|
avbdev/siksha
|
client/src/components/atoms/Table/TableHeaders.tsx
|
import React from "react";
import { isPrimitive } from "./Utils";
export interface IRenderHeaderProps {
headerProps?: any;
headerContainerProps?: any;
headers?: any[];
}
export const RenderHeaders: React.FC<IRenderHeaderProps> = (props) => {
const { headerProps, headerContainerProps, headers } = props;
return (
<thead>
<tr>
{headers &&
headers.map((header, index) => {
return <th key={index}>{isPrimitive(header) ? header : ""}</th>;
})}
</tr>
</thead>
);
};
|
avbdev/siksha
|
client/src/utils/endpoints/DeleteEndPoints.ts
|
<gh_stars>0
export enum DeleteEndPoint {}
|
avbdev/siksha
|
client/src/components/atoms/Table/Table.tsx
|
<filename>client/src/components/atoms/Table/Table.tsx<gh_stars>0
import React from "react";
import "./Table.css";
import { IRenderBodyProps, RenderBody } from "./TableBody";
import { IRenderHeaderProps, RenderHeaders } from "./TableHeaders";
interface ITableProps extends IRenderBodyProps, IRenderHeaderProps {}
export const Table: React.FC<ITableProps> = ({ items, headers }) => {
if (!(items && items?.length)) return <></>;
const keys: any[] = Object.keys(items[0]);
return (
<div>
<table>
<RenderHeaders
{...{ headers: headers && headers.length > 0 ? headers : keys }}
/>
<RenderBody {...{ items: items }} />
</table>
</div>
);
};
|
avbdev/siksha
|
client/src/mock/mock.ts
|
import { IApps } from "../components/atoms/Table";
export const apps: IApps[] = [
{
__Id: 1,
AppName: "Span",
AppId: "a0cd0b56-7a8a-44e6-960a-59473b39aed8",
Owner: "ostemson0",
UsersCount: 15,
},
{
__Id: 2,
AppName: "Solarbreeze",
AppId: "72e193ab-42da-4191-a965-db2056f4c468",
Owner: "ddarkins1",
UsersCount: 321,
},
{
__Id: 3,
AppName: "Aerified",
AppId: "6198d6c0-3e23-4017-867f-537cc063b8ce",
Owner: "bmouton2",
UsersCount: 145,
},
{
__Id: 4,
AppName: "Zaam-Dox",
AppId: "6d31a339-0ac1-4602-b6b3-ab5aee2c7b02",
Owner: "sbrash3",
UsersCount: 51,
},
{
__Id: 5,
AppName: "It",
AppId: "1d2d6cdc-1f3e-4f2a-9535-666672ab8582",
Owner: "jewles4",
UsersCount: 600,
},
{
__Id: 6,
AppName: "Stringtough",
AppId: "721a7699-dc22-41ef-be0e-801d7e6f4e8e",
Owner: "kcrowhurst5",
UsersCount: 920,
},
{
__Id: 7,
AppName: "Bamity",
AppId: "b8f68b2d-59d6-49eb-8783-e2a9ded5bf85",
Owner: "lwyndham6",
UsersCount: 97,
},
{
__Id: 8,
AppName: "Voyatouch",
AppId: "036950f5-86a1-4382-8fd5-1bfc8be076c0",
Owner: "hdellcasa7",
UsersCount: 41,
},
{
__Id: 9,
AppName: "Fintone",
AppId: "642b34d6-08a2-44f8-8a77-166355d95e1c",
Owner: "febbins8",
UsersCount: 975,
},
{
__Id: 10,
AppName: "Opela",
AppId: "060cb83c-726a-4d92-8dc7-3198caf807b0",
Owner: "doolahan9",
UsersCount: 695,
},
{
__Id: 11,
AppName: "Wrapsafe",
AppId: "b30cd369-33a5-4b7e-827b-e35324c907b3",
Owner: "gmephana",
UsersCount: 223,
},
{
__Id: 12,
AppName: "Tresom",
AppId: "ca41293a-c821-4495-a33e-204b3ac7b45c",
Owner: "qarthanb",
UsersCount: 468,
},
{
__Id: 13,
AppName: "Bytecard",
AppId: "47e5c7f7-4cf3-4e97-bf6a-3f75aec07b6a",
Owner: "docorrenc",
UsersCount: 136,
},
{
__Id: 14,
AppName: "Opela",
AppId: "a13d9647-d4c4-4515-b75b-eb086d90ed09",
Owner: "credshawd",
UsersCount: 64,
},
{
__Id: 15,
AppName: "Konklux",
AppId: "82435b95-8e24-4904-aaeb-8fefabb64b68",
Owner: "cpetrovykhe",
UsersCount: 728,
},
{
__Id: 16,
AppName: "Tin",
AppId: "618a468c-1a1c-4c9a-9956-0c8d41048b59",
Owner: "kmacdougallf",
UsersCount: 937,
},
{
__Id: 17,
AppName: "Tampflex",
AppId: "64426a8d-600f-40f5-b7ac-9a3d8ffb584c",
Owner: "bcasbong",
UsersCount: 780,
},
{
__Id: 18,
AppName: "Alphazap",
AppId: "36f56fe2-c9a5-455a-99e0-38bd29feca7a",
Owner: "ehumphriesh",
UsersCount: 667,
},
{
__Id: 19,
AppName: "Wrapsafe",
AppId: "a3108f64-98c6-47a9-8689-fe7e02000d65",
Owner: "pmulberyi",
UsersCount: 358,
},
// {
// Id: 20,
// appName: "Sub-Ex",
// appId: "97acb369-d963-4068-a81d-c28b0822fd03",
// owner: "lpetscheltj",
// usersCount: 856,
// },
// {
// Id: 21,
// appName: "Biodex",
// appId: "ed86a413-99f5-487a-a5b0-9ba07d6cd860",
// owner: "wslaterk",
// usersCount: 110,
// },
// {
// Id: 22,
// appName: "Prodder",
// appId: "1c9b6641-224a-4ef4-862e-cc012ecbbe99",
// owner: "ebrommagel",
// usersCount: 396,
// },
// {
// Id: 23,
// appName: "Zontrax",
// appId: "9c271da4-fd7c-43dd-9564-0c248cb82bad",
// owner: "cdyersonm",
// usersCount: 351,
// },
// {
// Id: 24,
// appName: "Keylex",
// appId: "5198cd16-131e-4f7d-8a42-1341a1dd74e4",
// owner: "groycroftn",
// usersCount: 892,
// },
// {
// Id: 25,
// appName: "Opela",
// appId: "79674cb3-37d6-44d7-8fd1-d45f168de2ee",
// owner: "cbutterwicko",
// usersCount: 270,
// },
// {
// Id: 26,
// appName: "Rank",
// appId: "b5cf02e5-1f74-4cda-b407-7dd511aa522d",
// owner: "gmaydwellp",
// usersCount: 53,
// },
// {
// Id: 27,
// appName: "Domainer",
// appId: "1ae28dc8-300d-419b-be66-2b2b6cba8a8f",
// owner: "scrainq",
// usersCount: 600,
// },
// {
// Id: 28,
// appName: "Tres-Zap",
// appId: "08899225-de24-4bd7-87b0-af3c09f6abc8",
// owner: "nwallbuttonr",
// usersCount: 837,
// },
// {
// Id: 29,
// appName: "Sonsing",
// appId: "a2b5e7e7-5a77-497f-a5d5-00938a5178af",
// owner: "trisens",
// usersCount: 856,
// },
// {
// Id: 30,
// appName: "Treeflex",
// appId: "9f9c3b66-87a9-4ee9-9ce3-841f61aabdeb",
// owner: "jelcombet",
// usersCount: 823,
// },
// {
// Id: 31,
// appName: "Tempsoft",
// appId: "0a9ec471-ae3a-49b3-bfb8-170508a50d29",
// owner: "wbartelsu",
// usersCount: 97,
// },
// {
// Id: 32,
// appName: "Ronstring",
// appId: "777defd8-4b82-4275-97a1-9ccf63ddb208",
// owner: "iberesforev",
// usersCount: 30,
// },
// {
// Id: 33,
// appName: "Aerified",
// appId: "0027f534-374b-45c0-a38d-e0bc404a686c",
// owner: "sdraysonw",
// usersCount: 561,
// },
// {
// Id: 34,
// appName: "Stronghold",
// appId: "50a7e763-8bf8-442a-9857-e9c457691173",
// owner: "ksmeesx",
// usersCount: 732,
// },
// {
// Id: 35,
// appName: "Y-Solowarm",
// appId: "164c71f9-d4cc-4b6a-9f9f-1ac34ae5851e",
// owner: "sthurlbourney",
// usersCount: 93,
// },
// {
// Id: 36,
// appName: "Job",
// appId: "9a82f236-0df8-487b-bfd0-bc6bd9cf9689",
// owner: "crenfreez",
// usersCount: 782,
// },
// {
// Id: 37,
// appName: "Fix San",
// appId: "3e423e25-b199-4893-be37-c6f5c142e2a4",
// owner: "obelle10",
// usersCount: 807,
// },
// {
// Id: 38,
// appName: "Sonsing",
// appId: "c6f0c450-7799-4984-b22e-d9c611553644",
// owner: "lrees11",
// usersCount: 295,
// },
// {
// Id: 39,
// appName: "Subin",
// appId: "db8f2487-87b4-4566-843a-7442185c9140",
// owner: "apaulin12",
// usersCount: 200,
// },
// {
// Id: 40,
// appName: "Zoolab",
// appId: "cee624db-b333-4879-b2b0-644ad6720e71",
// owner: "ccotter13",
// usersCount: 544,
// },
// {
// Id: 41,
// appName: "Greenlam",
// appId: "f5c76099-dd80-4fc4-868c-d2b5a4d4472e",
// owner: "ssarfat14",
// usersCount: 953,
// },
// {
// Id: 42,
// appName: "Vagram",
// appId: "bae259cc-b729-41a5-8ab4-3cc6dacdb94f",
// owner: "eweeden15",
// usersCount: 858,
// },
// {
// Id: 43,
// appName: "Cookley",
// appId: "9c062329-9011-4d21-ba3d-6f9a4e008c2a",
// owner: "smedley16",
// usersCount: 614,
// },
// {
// Id: 44,
// appName: "Cardify",
// appId: "71529c27-0d3e-4e8f-b15b-c7dcd1c68285",
// owner: "smuris17",
// usersCount: 511,
// },
// {
// Id: 45,
// appName: "Y-Solowarm",
// appId: "55ce4b7f-d332-436e-8580-ec0e161d707d",
// owner: "lspeares18",
// usersCount: 830,
// },
// {
// Id: 46,
// appName: "Zoolab",
// appId: "47cb50a1-241b-4bd6-8806-efb2dd07aefa",
// owner: "cmotherwell19",
// usersCount: 898,
// },
// {
// Id: 47,
// appName: "Y-Solowarm",
// appId: "067a66b9-ea7a-41ae-9039-eeccef0da629",
// owner: "ocorhard1a",
// usersCount: 764,
// },
// {
// Id: 48,
// appName: "Daltfresh",
// appId: "b0f5b825-3b8c-47fc-9b10-0ca6907206da",
// owner: "mcheng1b",
// usersCount: 230,
// },
// {
// Id: 49,
// appName: "Tampflex",
// appId: "39d64321-b4ed-467c-815e-749e4f5f37c0",
// owner: "lgudgin1c",
// usersCount: 748,
// },
// {
// Id: 50,
// appName: "Redhold",
// appId: "2dd06fab-1dad-4ee7-b13b-ec8fb760d90e",
// owner: "cboldra1d",
// usersCount: 346,
// },
// {
// Id: 51,
// appName: "Biodex",
// appId: "46bcf595-69d4-41c0-a05c-6b5fd027c277",
// owner: "bspellard1e",
// usersCount: 159,
// },
// {
// Id: 52,
// appName: "Bitchip",
// appId: "aa2fbbec-3c96-4317-8576-7c1bc5183e10",
// owner: "caguirrezabal1f",
// usersCount: 847,
// },
// {
// Id: 53,
// appName: "Tampflex",
// appId: "6dea34cf-faf0-4f97-9da3-d8ecdbd8b7f8",
// owner: "mwines1g",
// usersCount: 628,
// },
// {
// Id: 54,
// appName: "Zaam-Dox",
// appId: "f6ef40d7-7c5e-4244-bd91-e5bafb1d4ce3",
// owner: "fruggles1h",
// usersCount: 655,
// },
// {
// Id: 55,
// appName: "Zontrax",
// appId: "737b10b6-735d-4c98-9552-e0310270041c",
// owner: "lnutbeem1i",
// usersCount: 893,
// },
// {
// Id: 56,
// appName: "Fix San",
// appId: "a678d2e7-3271-46a8-979d-c0d7f15f8847",
// owner: "htilburn1j",
// usersCount: 773,
// },
// {
// Id: 57,
// appName: "Alphazap",
// appId: "da2baf9b-be12-4574-9ded-90d647b1c412",
// owner: "jgarrat1k",
// usersCount: 846,
// },
// {
// Id: 58,
// appName: "Overhold",
// appId: "51122bb9-866f-43ab-b20c-32be1dd82d4a",
// owner: "gclaibourn1l",
// usersCount: 937,
// },
// {
// Id: 59,
// appName: "Sonair",
// appId: "f85603d1-6ce7-4f07-bb64-b38a7bc92560",
// owner: "hjoe1m",
// usersCount: 370,
// },
// {
// Id: 60,
// appName: "Bamity",
// appId: "648ddd2e-25fb-4aff-baa9-ac730561663c",
// owner: "ogidley1n",
// usersCount: 841,
// },
// {
// Id: 61,
// appName: "Redhold",
// appId: "87e5eac4-3172-41ca-aadd-4144582b55e2",
// owner: "rmerrgan1o",
// usersCount: 284,
// },
// {
// Id: 62,
// appName: "Zoolab",
// appId: "315cff6d-0c87-4f55-8515-c2bb89b1ec83",
// owner: "whattrick1p",
// usersCount: 934,
// },
// {
// Id: 63,
// appName: "Y-Solowarm",
// appId: "e5c553e1-dffa-427e-96c8-67b7cb098ca1",
// owner: "cfeaver1q",
// usersCount: 460,
// },
// {
// Id: 64,
// appName: "Toughjoyfax",
// appId: "9610eb17-b3b2-4ac1-8fb8-2381a453d43f",
// owner: "fcawthery1r",
// usersCount: 120,
// },
// {
// Id: 65,
// appName: "Aerified",
// appId: "9430b18c-6ca1-4852-bbb9-829cc2d26de5",
// owner: "eedginton1s",
// usersCount: 520,
// },
// {
// Id: 66,
// appName: "Konklux",
// appId: "c2792807-9ecb-4925-a753-83d5b3cb30c3",
// owner: "kdackombe1t",
// usersCount: 558,
// },
// {
// Id: 67,
// appName: "Fintone",
// appId: "01891167-dedd-4431-ad8e-6510ad264d0d",
// owner: "aorrow1u",
// usersCount: 308,
// },
// {
// Id: 68,
// appName: "Temp",
// appId: "25487630-0b3e-4c0d-9305-18ad4248a7d6",
// owner: "storrecilla1v",
// usersCount: 828,
// },
// {
// Id: 69,
// appName: "It",
// appId: "2aff4ef4-3ee0-4b19-997a-e5d7b64df627",
// owner: "cchartre1w",
// usersCount: 887,
// },
// {
// Id: 70,
// appName: "Lotstring",
// appId: "f6207735-c7a0-4cfc-9ddd-7f27b3d19f80",
// owner: "ppennick1x",
// usersCount: 834,
// },
// {
// Id: 71,
// appName: "Job",
// appId: "0ce90501-7cc3-4149-b3a2-e9dbf009a756",
// owner: "galanbrooke1y",
// usersCount: 90,
// },
// {
// Id: 72,
// appName: "Zoolab",
// appId: "67d0feb6-10de-4776-8641-4280202ccef3",
// owner: "lbaird1z",
// usersCount: 76,
// },
// {
// Id: 73,
// appName: "Zamit",
// appId: "2860213a-594a-45c2-b6aa-46358aeda4da",
// owner: "dpratley20",
// usersCount: 213,
// },
// {
// Id: 74,
// appName: "Bytecard",
// appId: "7b7b70e9-2277-4bcf-9648-46a6f35df951",
// owner: "dstacy21",
// usersCount: 629,
// },
// {
// Id: 75,
// appName: "Viva",
// appId: "6bc11542-6140-461a-bdca-f39ddf9a680d",
// owner: "hwitnall22",
// usersCount: 566,
// },
// {
// Id: 76,
// appName: "<NAME>",
// appId: "854ddf6f-46c6-4ee0-b49c-7e2f925f035d",
// owner: "dhinks23",
// usersCount: 576,
// },
// {
// Id: 77,
// appName: "Opela",
// appId: "3236a298-8c4d-4fe5-85da-cc9c1bd3cf4b",
// owner: "cwrennall24",
// usersCount: 360,
// },
// {
// Id: 78,
// appName: "Sonair",
// appId: "b94c13ea-b95d-46f4-96e7-a89b74cae75a",
// owner: "vhellwing25",
// usersCount: 309,
// },
// {
// Id: 79,
// appName: "Fix San",
// appId: "1a71e1f5-b689-4b82-a4e7-34ff999de0fa",
// owner: "ldumbare26",
// usersCount: 812,
// },
// {
// Id: 80,
// appName: "Zoolab",
// appId: "7a79115b-71cc-4073-8dd7-850b08a53d4f",
// owner: "eshermore27",
// usersCount: 897,
// },
// {
// Id: 81,
// appName: "Keylex",
// appId: "0d58f6bf-7f92-4319-9fc8-cdd9331a87d0",
// owner: "eambage28",
// usersCount: 802,
// },
// {
// Id: 82,
// appName: "Latlux",
// appId: "96ae1082-6553-4982-8c8e-8850078f6014",
// owner: "ngotter29",
// usersCount: 572,
// },
// {
// Id: 83,
// appName: "Tampflex",
// appId: "ce5ccbdc-6c19-42e9-b734-4693c972b4b1",
// owner: "ivanoord2a",
// usersCount: 917,
// },
// {
// Id: 84,
// appName: "Regrant",
// appId: "16a90fcc-1a5a-45e2-baa5-159cae0b6326",
// owner: "sseatter2b",
// usersCount: 508,
// },
// {
// Id: 85,
// appName: "Bigtax",
// appId: "ae6a72f6-1002-45d7-bfcd-004458ca5f8a",
// owner: "moehm2c",
// usersCount: 684,
// },
// {
// Id: 86,
// appName: "Greenlam",
// appId: "a1e423ee-2104-436c-a89a-7d7eb0febf74",
// owner: "dmulcaster2d",
// usersCount: 667,
// },
// {
// Id: 87,
// appName: "Redhold",
// appId: "3236ae7b-fe6e-43b5-bf88-bb54a04865a3",
// owner: "nmoulding2e",
// usersCount: 848,
// },
// {
// Id: 88,
// appName: "Fixflex",
// appId: "aa25f288-f66e-4ef6-b04a-aa9c5aa3ecec",
// owner: "msumption2f",
// usersCount: 307,
// },
// {
// Id: 89,
// appName: "Prodder",
// appId: "f73bd3dd-9c27-4793-b309-e557edfe9903",
// owner: "hmccullouch2g",
// usersCount: 167,
// },
// {
// Id: 90,
// appName: "Tres-Zap",
// appId: "76f8620b-2244-47d5-a22b-5025bf184e41",
// owner: "fcampos2h",
// usersCount: 995,
// },
// {
// Id: 91,
// appName: "Voltsillam",
// appId: "77cb17f0-bc08-4765-8b49-e73087abe70c",
// owner: "jphilbrook2i",
// usersCount: 234,
// },
// {
// Id: 92,
// appName: "Sub-Ex",
// appId: "0a0b90d9-77b4-4abd-8b36-a1bf7f233fc4",
// owner: "cscotchmur2j",
// usersCount: 434,
// },
// {
// Id: 93,
// appName: "It",
// appId: "0fd31a48-c1fb-413b-b7ef-7469b03124f7",
// owner: "rgurley2k",
// usersCount: 367,
// },
// {
// Id: 94,
// appName: "Konklab",
// appId: "d5ee1427-88a5-4de6-84db-73cf06fea6ef",
// owner: "eriach2l",
// usersCount: 817,
// },
// {
// Id: 95,
// appName: "It",
// appId: "1bf0954d-ca5b-40e8-905e-8c4e0f8c2a9a",
// owner: "bvick2m",
// usersCount: 398,
// },
// {
// Id: 96,
// appName: "Cookley",
// appId: "3d9e4392-89b7-42e5-a149-d5029b1fdb9b",
// owner: "cbleaden2n",
// usersCount: 203,
// },
// {
// Id: 97,
// appName: "Duobam",
// appId: "9c219af6-7a4b-4c70-9c12-f9ca77866bd0",
// owner: "sbuston2o",
// usersCount: 186,
// },
// {
// Id: 98,
// appName: "Biodex",
// appId: "1562abb1-0479-4be1-90a3-4626ffd82476",
// owner: "ocolafate2p",
// usersCount: 341,
// },
// {
// Id: 99,
// appName: "<NAME>",
// appId: "e36084a8-9be0-46e7-8aaa-12f219ef103f",
// owner: "tketley2q",
// usersCount: 125,
// },
// {
// Id: 100,
// appName: "Matsoft",
// appId: "87199aca-ef33-43fc-ac24-f7a7a498e933",
// owner: "rpawlett2r",
// usersCount: 367,
// },
// {
// Id: 101,
// appName: "Gembucket",
// appId: "a81165b4-e819-4a33-9aac-4a52b9ec94da",
// owner: "pganniclifft2s",
// usersCount: 569,
// },
// {
// Id: 102,
// appName: "Kanlam",
// appId: "ab0656d5-33d1-4736-9bfd-787f5f3e69b4",
// owner: "rdaughton2t",
// usersCount: 816,
// },
// {
// Id: 103,
// appName: "Bigtax",
// appId: "9e68993d-226d-4d60-b74c-14112a839f94",
// owner: "dkeane2u",
// usersCount: 383,
// },
// {
// Id: 104,
// appName: "Bytecard",
// appId: "a5cfca1e-c4c9-45dc-b171-bea3be10d0e4",
// owner: "nmcmurraya2v",
// usersCount: 136,
// },
// {
// Id: 105,
// appName: "Aerified",
// appId: "17f1830b-c14c-477d-bf67-2caba2e538b8",
// owner: "oprinett2w",
// usersCount: 646,
// },
// {
// Id: 106,
// appName: "Voyatouch",
// appId: "f085a47c-63fb-4661-b323-3595db3d8ca8",
// owner: "tbraunds2x",
// usersCount: 873,
// },
// {
// Id: 107,
// appName: "Cardify",
// appId: "3342dd02-3256-4485-9611-357324acb3b0",
// owner: "ckorting2y",
// usersCount: 451,
// },
// {
// Id: 108,
// appName: "Ventosanzap",
// appId: "d6625610-fd31-4b01-9fc8-6a742cf6fde9",
// owner: "rgabey2z",
// usersCount: 558,
// },
// {
// Id: 109,
// appName: "Zathin",
// appId: "786e4cdc-7c58-4d1b-9edb-26765190aaf0",
// owner: "hclarycott30",
// usersCount: 687,
// },
// {
// Id: 110,
// appName: "Home Ing",
// appId: "3940b3de-7db5-4883-a238-32802c50dc63",
// owner: "edevonshire31",
// usersCount: 910,
// },
// {
// Id: 111,
// appName: "Lotlux",
// appId: "7730ec5b-9ee2-4b4b-8054-05659d9abca7",
// owner: "srossant32",
// usersCount: 692,
// },
// {
// Id: 112,
// appName: "Stringtough",
// appId: "b726a27a-c135-4dbc-908f-7cb8591a39fd",
// owner: "tadamski33",
// usersCount: 521,
// },
// {
// Id: 113,
// appName: "Bytecard",
// appId: "8cd017cd-ac15-49d9-b5f9-dedc7807881b",
// owner: "vreyes34",
// usersCount: 40,
// },
// {
// Id: 114,
// appName: "Greenlam",
// appId: "abb61031-c450-4d8c-a5bb-2ac0087d49ca",
// owner: "tdevin35",
// usersCount: 593,
// },
// {
// Id: 115,
// appName: "Pannier",
// appId: "9032a5b2-b7d7-4f1b-a3a5-cd060d9d2057",
// owner: "jlaughlan36",
// usersCount: 452,
// },
// {
// Id: 116,
// appName: "Toughjoyfax",
// appId: "f1a09087-975d-430c-bcba-a14a04fc22a7",
// owner: "lneal37",
// usersCount: 584,
// },
// {
// Id: 117,
// appName: "Toughjoyfax",
// appId: "5363dcc2-c73f-4e02-86ca-1893018c4d91",
// owner: "bstealy38",
// usersCount: 894,
// },
// {
// Id: 118,
// appName: "Matsoft",
// appId: "a5640480-23d5-41c9-8323-ba30a6d29b6d",
// owner: "areadie39",
// usersCount: 962,
// },
// {
// Id: 119,
// appName: "Aerified",
// appId: "614b33a3-b974-4d8f-a87d-d048f2dca5fa",
// owner: "cmerchant3a",
// usersCount: 92,
// },
// {
// Id: 120,
// appName: "Hatity",
// appId: "b2f27650-ce35-45af-a918-81293f87a3e0",
// owner: "vcrouse3b",
// usersCount: 929,
// },
// {
// Id: 121,
// appName: "Viva",
// appId: "33706efa-b3ff-4208-89b5-f50caf74c484",
// owner: "jgiraux3c",
// usersCount: 707,
// },
// {
// Id: 122,
// appName: "Tres-Zap",
// appId: "6bd3de54-7a41-4a51-924d-bdbade0d8679",
// owner: "idematteis3d",
// usersCount: 351,
// },
// {
// Id: 123,
// appName: "Fixflex",
// appId: "a38b7fd0-e16e-4bd2-b4fa-1a0f2d930a71",
// owner: "rdrohane3e",
// usersCount: 588,
// },
// {
// Id: 124,
// appName: "Hatity",
// appId: "f04eb261-fc67-42ee-8774-168635c94b7f",
// owner: "fledwidge3f",
// usersCount: 547,
// },
// {
// Id: 125,
// appName: "Prodder",
// appId: "0dba059d-bea0-4304-b93f-d4aadc352929",
// owner: "abolton3g",
// usersCount: 166,
// },
// {
// Id: 126,
// appName: "Keylex",
// appId: "3df36960-ff90-4276-9cf9-7c4652192cf2",
// owner: "mguinnane3h",
// usersCount: 488,
// },
// {
// Id: 127,
// appName: "Temp",
// appId: "0e6acc64-eef1-44ee-baec-99efe4353ba9",
// owner: "dcrocombe3i",
// usersCount: 965,
// },
// {
// Id: 128,
// appName: "Stronghold",
// appId: "056fb5ce-b225-4d12-ae49-2397e591030a",
// owner: "amckerlie3j",
// usersCount: 306,
// },
// {
// Id: 129,
// appName: "Zontrax",
// appId: "b93424c9-e66d-4394-9745-25fd1191d3cf",
// owner: "dholberry3k",
// usersCount: 393,
// },
// {
// Id: 130,
// appName: "Latlux",
// appId: "9af28029-7877-4a4c-918a-d474e085ba5f",
// owner: "sbener3l",
// usersCount: 781,
// },
// {
// Id: 131,
// appName: "Viva",
// appId: "ecc3a9ea-7be8-4b0d-93c3-67a0c874955d",
// owner: "rgilardoni3m",
// usersCount: 843,
// },
// {
// Id: 132,
// appName: "Redhold",
// appId: "764d802b-3a9f-498b-8079-7977b2484eac",
// owner: "sblest3n",
// usersCount: 791,
// },
// {
// Id: 133,
// appName: "Tampflex",
// appId: "6722a469-f02a-442a-ac63-a875155c3607",
// owner: "shatherall3o",
// usersCount: 304,
// },
// {
// Id: 134,
// appName: "Flowdesk",
// appId: "046360d2-393f-46e6-8885-c53d65c99ebd",
// owner: "mgarfoot3p",
// usersCount: 334,
// },
// {
// Id: 135,
// appName: "Kanlam",
// appId: "59d6b1c3-312c-4ce8-bec4-1f252b0cd3d4",
// owner: "jtruesdale3q",
// usersCount: 811,
// },
// {
// Id: 136,
// appName: "Fintone",
// appId: "674b5442-00ea-4a56-9010-9aa8e322bd2c",
// owner: "croyson3r",
// usersCount: 117,
// },
// {
// Id: 137,
// appName: "Bigtax",
// appId: "fb799f82-22da-4bb0-859e-3f067fc17c98",
// owner: "cblackborow3s",
// usersCount: 819,
// },
// {
// Id: 138,
// appName: "Voyatouch",
// appId: "665cf210-8b0c-452a-aef7-c02b4746ec6b",
// owner: "tschuck3t",
// usersCount: 533,
// },
// {
// Id: 139,
// appName: "Prodder",
// appId: "0379387d-9b14-488e-bba4-317f29e3e449",
// owner: "dharriot3u",
// usersCount: 401,
// },
// {
// Id: 140,
// appName: "It",
// appId: "4e8cebca-ea12-4015-8c27-5f19fe076b13",
// owner: "ahannan3v",
// usersCount: 751,
// },
// {
// Id: 141,
// appName: "Holdlamis",
// appId: "fd7d5b82-fca8-42ce-a3d4-32f4836cbfa0",
// owner: "lgriffey3w",
// usersCount: 319,
// },
// {
// Id: 142,
// appName: "Cookley",
// appId: "dd83fb5a-9cbb-462c-8fa1-d1107c87e5f9",
// owner: "sjillis3x",
// usersCount: 48,
// },
// {
// Id: 143,
// appName: "Viva",
// appId: "912588d5-977e-4991-b9cc-17f4a4931978",
// owner: "befford3y",
// usersCount: 498,
// },
// {
// Id: 144,
// appName: "Sonair",
// appId: "22d75fc4-c95c-466a-ac65-41f6203cf4a4",
// owner: "sluparto3z",
// usersCount: 68,
// },
// {
// Id: 145,
// appName: "Zaam-Dox",
// appId: "86ab4f25-df25-4507-86f9-1c20e2ea1ee8",
// owner: "gwhiffen40",
// usersCount: 996,
// },
// {
// Id: 146,
// appName: "Subin",
// appId: "91e9b5ce-7cac-42cc-b987-e4c788263f56",
// owner: "bwandrey41",
// usersCount: 262,
// },
// {
// Id: 147,
// appName: "Y-find",
// appId: "de79882c-ddba-42fe-97cc-d2f8882b1c76",
// owner: "kscoggin42",
// usersCount: 513,
// },
// {
// Id: 148,
// appName: "Zoolab",
// appId: "4e91768f-4ee9-4cdf-8d5f-0319de0ef1fc",
// owner: "mcrissil43",
// usersCount: 126,
// },
// {
// Id: 149,
// appName: "Trippledex",
// appId: "4cd80af4-47b9-482b-adeb-8557d6ad425f",
// owner: "agrealey44",
// usersCount: 493,
// },
// {
// Id: 150,
// appName: "Voltsillam",
// appId: "fcacaf9e-377d-4e33-985b-a3542405860f",
// owner: "adecristofalo45",
// usersCount: 888,
// },
// {
// Id: 151,
// appName: "Konklab",
// appId: "d5025d4b-9dcc-403b-bf36-ec69514d940c",
// owner: "ichretien46",
// usersCount: 300,
// },
// {
// Id: 152,
// appName: "Lotlux",
// appId: "5f9651fe-72c3-4613-bcf0-a548d44e30e1",
// owner: "sambrogetti47",
// usersCount: 459,
// },
// {
// Id: 153,
// appName: "Zamit",
// appId: "006d8ff8-4224-4730-930a-c94d23138258",
// owner: "dsowley48",
// usersCount: 132,
// },
// {
// Id: 154,
// appName: "Tampflex",
// appId: "ea48499a-8589-4e5c-8669-7132311b7422",
// owner: "mskeemer49",
// usersCount: 633,
// },
// {
// Id: 155,
// appName: "Greenlam",
// appId: "6364eb04-6d86-42e2-a9e1-a93fb77a599d",
// owner: "nwinfrey4a",
// usersCount: 152,
// },
// {
// Id: 156,
// appName: "Asoka",
// appId: "a2338233-6a5a-48f7-b4bd-7ff6522b36b3",
// owner: "wdomanski4b",
// usersCount: 926,
// },
// {
// Id: 157,
// appName: "Toughjoyfax",
// appId: "096d22bd-ce3a-4d13-abd3-58f34f428fd6",
// owner: "gsherman4c",
// usersCount: 874,
// },
// {
// Id: 158,
// appName: "Bamity",
// appId: "4b296309-50b8-457f-bf7c-ad6e5e0b7a13",
// owner: "mpatel4d",
// usersCount: 921,
// },
// {
// Id: 159,
// appName: "Biodex",
// appId: "90c18b88-5c05-4839-9995-0f2851bf37f0",
// owner: "dcawthry4e",
// usersCount: 903,
// },
// {
// Id: 160,
// appName: "Prodder",
// appId: "387eb8f8-88b0-4ab8-8192-ad57da1bb32a",
// owner: "mgrigori4f",
// usersCount: 875,
// },
// {
// Id: 161,
// appName: "Fix San",
// appId: "7c605beb-fa83-44c5-975a-458239f7bd95",
// owner: "crhyme4g",
// usersCount: 299,
// },
// {
// Id: 162,
// appName: "Solarbreeze",
// appId: "dea94f63-df03-4e94-a55c-15f48bdd9704",
// owner: "hhaley4h",
// usersCount: 192,
// },
// {
// Id: 163,
// appName: "Hatity",
// appId: "3578471d-1164-4f94-996c-d10d9f935755",
// owner: "sweller4i",
// usersCount: 186,
// },
// {
// Id: 164,
// appName: "Alpha",
// appId: "fce86c4f-ff43-4d1b-bbe8-8ee2e18c9272",
// owner: "jpaskerful4j",
// usersCount: 867,
// },
// {
// Id: 165,
// appName: "Stringtough",
// appId: "7cfa398d-2401-467f-96fe-74128e62b022",
// owner: "llindell4k",
// usersCount: 29,
// },
// {
// Id: 166,
// appName: "Bigtax",
// appId: "156654b1-ae18-4d5e-9359-fddd806db9bd",
// owner: "raspinwall4l",
// usersCount: 591,
// },
// {
// Id: 167,
// appName: "Flowdesk",
// appId: "e0e34f1b-b88b-4b2c-914b-87b74a7be709",
// owner: "ematzkaitis4m",
// usersCount: 439,
// },
// {
// Id: 168,
// appName: "Regrant",
// appId: "87d1ff1a-c5b3-4e6d-801f-e217c3a7c783",
// owner: "mblasio4n",
// usersCount: 698,
// },
// {
// Id: 169,
// appName: "Flexidy",
// appId: "5a669d06-53fb-4f6e-b2fa-0d0b0ab1a131",
// owner: "aseacombe4o",
// usersCount: 640,
// },
// {
// Id: 170,
// appName: "Bigtax",
// appId: "25bfbb25-0a18-4f1b-8568-c546c60c6241",
// owner: "mmadgwick4p",
// usersCount: 177,
// },
// {
// Id: 171,
// appName: "Domainer",
// appId: "a6a428f6-025a-412b-9975-a09ee06112dd",
// owner: "rthorius4q",
// usersCount: 460,
// },
// {
// Id: 172,
// appName: "Veribet",
// appId: "05904106-e294-4f08-a3a0-e947741a3adb",
// owner: "etarburn4r",
// usersCount: 753,
// },
// {
// Id: 173,
// appName: "Home Ing",
// appId: "1d8ab4d9-d6b5-4c14-88ba-77f6db973e0a",
// owner: "ppietroni4s",
// usersCount: 46,
// },
// {
// Id: 174,
// appName: "Y-find",
// appId: "61cf767f-9d68-4eb2-9598-22161b32448f",
// owner: "akinnerk4t",
// usersCount: 436,
// },
// {
// Id: 175,
// appName: "Opela",
// appId: "25ab0010-5a3d-4329-b9a2-244c36c3da69",
// owner: "kletrange4u",
// usersCount: 585,
// },
// {
// Id: 176,
// appName: "Y-find",
// appId: "78979987-e023-4fa5-ba3d-e43cb8b1745c",
// owner: "iburtonwood4v",
// usersCount: 68,
// },
// {
// Id: 177,
// appName: "Solarbreeze",
// appId: "17e18aa3-8e9e-4e4c-ac75-3553bdc0b87d",
// owner: "eantoniat4w",
// usersCount: 801,
// },
// {
// Id: 178,
// appName: "Gembucket",
// appId: "93bad99d-43f3-44cb-8da2-e8301c659f4c",
// owner: "bmingauld4x",
// usersCount: 357,
// },
// {
// Id: 179,
// appName: "Trippledex",
// appId: "ab86fc27-b68f-4961-91b9-3d25341a34c6",
// owner: "aposchel4y",
// usersCount: 670,
// },
// {
// Id: 180,
// appName: "Stringtough",
// appId: "312720f9-19c9-4559-a945-d578559c5513",
// owner: "oheninghem4z",
// usersCount: 659,
// },
// {
// Id: 181,
// appName: "Sonsing",
// appId: "93a1398d-abc2-4f22-8ad9-3abe2cbc1101",
// owner: "sspraggs50",
// usersCount: 347,
// },
// {
// Id: 182,
// appName: "Tresom",
// appId: "0e16981a-6266-493a-8c24-831b2f57a00f",
// owner: "cwhichelow51",
// usersCount: 453,
// },
// {
// Id: 183,
// appName: "Solarbreeze",
// appId: "1fde8d22-815e-4a5c-9ca7-9e89439b1c7d",
// owner: "pstoddard52",
// usersCount: 177,
// },
// {
// Id: 184,
// appName: "Stronghold",
// appId: "0587320a-1227-4b1a-9162-dc242bf28122",
// owner: "pbemrose53",
// usersCount: 358,
// },
// {
// Id: 185,
// appName: "Vagram",
// appId: "8519b274-cb20-42eb-b498-4789c35a3e2f",
// owner: "rivashintsov54",
// usersCount: 462,
// },
// {
// Id: 186,
// appName: "Flowdesk",
// appId: "1cd35e6d-c20c-48ba-92a0-ccade46592a0",
// owner: "cstreeter55",
// usersCount: 956,
// },
// {
// Id: 187,
// appName: "Stronghold",
// appId: "cacaa630-8060-4b2b-8e3a-4a50302a3e7e",
// owner: "gscotfurth56",
// usersCount: 935,
// },
// {
// Id: 188,
// appName: "Wrapsafe",
// appId: "d9b1c296-a498-4ace-a204-8c51665a1143",
// owner: "kguitte57",
// usersCount: 39,
// },
// {
// Id: 189,
// appName: "Ronstring",
// appId: "1c7ba6e5-9e3a-4a0f-b604-2fe8a3faefa8",
// owner: "kgudgen58",
// usersCount: 744,
// },
// {
// Id: 190,
// appName: "Sub-Ex",
// appId: "8e6f0c8e-0ea3-494c-b929-8c95cf5c8f71",
// owner: "yjosephy59",
// usersCount: 122,
// },
// {
// Id: 191,
// appName: "Pannier",
// appId: "e0ddebe8-ef89-4bfe-afc6-378508ced2cd",
// owner: "chaccleton5a",
// usersCount: 894,
// },
// {
// Id: 192,
// appName: "Cookley",
// appId: "0a5214f5-5e83-48ef-8a78-c1a473fa6ef0",
// owner: "gchislett5b",
// usersCount: 68,
// },
// {
// Id: 193,
// appName: "Sonsing",
// appId: "70a582b5-3ee5-4fd0-b29e-fa8234ac1e36",
// owner: "csherwen5c",
// usersCount: 398,
// },
// {
// Id: 194,
// appName: "Otcom",
// appId: "548f79b4-8547-4b56-bfda-db7b8512252c",
// owner: "lwaitland5d",
// usersCount: 456,
// },
// {
// Id: 195,
// appName: "Quo Lux",
// appId: "6716eb62-0fcb-424b-9b2a-9afcd91ed563",
// owner: "cclamp5e",
// usersCount: 848,
// },
// {
// Id: 196,
// appName: "Opela",
// appId: "ad9823a4-7c59-4a0c-a846-e4fd773c0287",
// owner: "agipps5f",
// usersCount: 799,
// },
// {
// Id: 197,
// appName: "Overhold",
// appId: "0045be3c-0957-44c8-8a3b-ab79f5e18825",
// owner: "mluffman5g",
// usersCount: 160,
// },
// {
// Id: 198,
// appName: "Lotstring",
// appId: "24353cb4-5574-4503-963b-98e07127b28c",
// owner: "mfell5h",
// usersCount: 861,
// },
// {
// Id: 199,
// appName: "Sub-Ex",
// appId: "1718f4d4-a070-4365-bdf5-16f14b968e47",
// owner: "mgigg5i",
// usersCount: 506,
// },
// {
// Id: 200,
// appName: "Fix San",
// appId: "4bd8b6cc-9547-488b-b58e-318cd15cf80b",
// owner: "abradbeer5j",
// usersCount: 385,
// },
// {
// Id: 201,
// appName: "Greenlam",
// appId: "484668c2-b1db-4f6d-afaa-ba8f92938e4d",
// owner: "pgiacubbo5k",
// usersCount: 231,
// },
// {
// Id: 202,
// appName: "Cardify",
// appId: "3a78a304-b0d9-492f-9102-678c718e92dc",
// owner: "cgarrett5l",
// usersCount: 46,
// },
// {
// Id: 203,
// appName: "Alpha",
// appId: "b24dc241-7111-432a-a36a-711809673492",
// owner: "zbartrum5m",
// usersCount: 930,
// },
// {
// Id: 204,
// appName: "Overhold",
// appId: "d44f71d0-89d5-4b89-a725-29bafcf36e2c",
// owner: "lmiche5n",
// usersCount: 483,
// },
// {
// Id: 205,
// appName: "Toughjoyfax",
// appId: "168b1475-2b4e-4bcb-93df-2cbf7019a4c3",
// owner: "bruddiman5o",
// usersCount: 251,
// },
// {
// Id: 206,
// appName: "Tresom",
// appId: "7f457eaf-2691-4060-b0f8-2330ade3c06f",
// owner: "ldeeves5p",
// usersCount: 136,
// },
// {
// Id: 207,
// appName: "Zoolab",
// appId: "d2205016-3291-4d0a-93e3-0ee503192a01",
// owner: "bflemmich5q",
// usersCount: 545,
// },
// {
// Id: 208,
// appName: "Cardify",
// appId: "769a9bea-c747-4ba9-9ae0-2fb426d25f30",
// owner: "gchaulk5r",
// usersCount: 299,
// },
// {
// Id: 209,
// appName: "Rank",
// appId: "e2aa4a94-a9b6-4eff-9c1e-27d89a1ae83c",
// owner: "brobe5s",
// usersCount: 920,
// },
// {
// Id: 210,
// appName: "Tin",
// appId: "59355449-0c89-4e57-95f5-e71537bafed8",
// owner: "fmcgilvra5t",
// usersCount: 949,
// },
// {
// Id: 211,
// appName: "Ventosanzap",
// appId: "504de113-68bf-4eab-a99f-b634bfb97241",
// owner: "pcraighall5u",
// usersCount: 864,
// },
// {
// Id: 212,
// appName: "Tampflex",
// appId: "9c4834c9-8a38-41e2-8b8b-6ca6e5ad2507",
// owner: "mklejin5v",
// usersCount: 455,
// },
// {
// Id: 213,
// appName: "Greenlam",
// appId: "28f50123-6eb0-439d-94bc-800dcfe6f81c",
// owner: "ffavey5w",
// usersCount: 424,
// },
// {
// Id: 214,
// appName: "Greenlam",
// appId: "e1a1003a-9e5d-4e31-b10a-a7f62483d2c4",
// owner: "smonketon5x",
// usersCount: 39,
// },
// {
// Id: 215,
// appName: "Latlux",
// appId: "0e898d04-0774-4309-bf29-60dd15e5befa",
// owner: "cmyerscough5y",
// usersCount: 89,
// },
// {
// Id: 216,
// appName: "Otcom",
// appId: "1d60d3ef-d88d-4400-9ca4-43da01bd3a42",
// owner: "gblindt5z",
// usersCount: 748,
// },
// {
// Id: 217,
// appName: "Voyatouch",
// appId: "a7734ce0-3add-46fd-abb2-f6acc81bc615",
// owner: "smacmurray60",
// usersCount: 498,
// },
// {
// Id: 218,
// appName: "Bigtax",
// appId: "fc732ede-0138-487e-866c-057cdf96fd39",
// owner: "bcreaney61",
// usersCount: 668,
// },
// {
// Id: 219,
// appName: "<NAME>",
// appId: "6f1f46a8-393e-445f-ab48-9b91adb2b621",
// owner: "rhethron62",
// usersCount: 274,
// },
// {
// Id: 220,
// appName: "Fix San",
// appId: "2e0b577c-8058-4932-ac77-b7daace5725c",
// owner: "gakrigg63",
// usersCount: 63,
// },
// {
// Id: 221,
// appName: "Toughjoyfax",
// appId: "0f22ecb2-6668-4f9d-b26c-cd9f81447f10",
// owner: "fgolagley64",
// usersCount: 531,
// },
// {
// Id: 222,
// appName: "Bamity",
// appId: "9f8512d8-82e0-42c4-9819-6bba6302ec1b",
// owner: "sdaspar65",
// usersCount: 134,
// },
// {
// Id: 223,
// appName: "Tresom",
// appId: "6d498e5a-7496-47bb-a340-6534de914507",
// owner: "ialeshkov66",
// usersCount: 135,
// },
// {
// Id: 224,
// appName: "Stim",
// appId: "d214f51f-04d4-47ce-907a-0381de16304e",
// owner: "eturbard67",
// usersCount: 798,
// },
// {
// Id: 225,
// appName: "Stringtough",
// appId: "dc398f4a-1912-41b7-8879-c9d49dedd380",
// owner: "lconechie68",
// usersCount: 904,
// },
// {
// Id: 226,
// appName: "Home Ing",
// appId: "d3dec83d-baaf-4592-8003-ff019d96c034",
// owner: "degglestone69",
// usersCount: 143,
// },
// {
// Id: 227,
// appName: "Tampflex",
// appId: "e9854682-8cba-4d2f-aa44-0d7a4b97a10f",
// owner: "hdutton6a",
// usersCount: 935,
// },
// {
// Id: 228,
// appName: "Fixflex",
// appId: "e7a90b12-4486-4000-8f57-19c99205fd24",
// owner: "omarshall6b",
// usersCount: 142,
// },
// {
// Id: 229,
// appName: "Flowdesk",
// appId: "e5f7e1a1-0a1c-420d-8943-28f4f7deac10",
// owner: "akleinerman6c",
// usersCount: 442,
// },
// {
// Id: 230,
// appName: "Transcof",
// appId: "84dff88c-4644-4092-9dff-6f3bd091334a",
// owner: "cbarmby6d",
// usersCount: 167,
// },
// {
// Id: 231,
// appName: "Keylex",
// appId: "e507aae1-ed5d-40c9-aec5-8af46c21c041",
// owner: "nbalwin6e",
// usersCount: 970,
// },
// {
// Id: 232,
// appName: "Otcom",
// appId: "db89bfe1-8e5e-42dc-bb4d-1eb884e4944f",
// owner: "askelhorne6f",
// usersCount: 508,
// },
// {
// Id: 233,
// appName: "Y-find",
// appId: "9415ead5-a992-4d2f-a8a8-570b06870d3d",
// owner: "mcreebo6g",
// usersCount: 14,
// },
// {
// Id: 234,
// appName: "Zaam-Dox",
// appId: "535b6d9c-bc26-4a87-8e9e-06cd673b3c53",
// owner: "cwych6h",
// usersCount: 71,
// },
// {
// Id: 235,
// appName: "Kanlam",
// appId: "68dcf507-c43d-4348-b410-7795a2eb3ae4",
// owner: "rdoumenc6i",
// usersCount: 120,
// },
// {
// Id: 236,
// appName: "Home Ing",
// appId: "5409b003-3adb-45b2-83c3-62974a4bd8e2",
// owner: "sbrik6j",
// usersCount: 649,
// },
// {
// Id: 237,
// appName: "Keylex",
// appId: "6b6d7826-5e42-4790-82c2-fbcd61c7d08c",
// owner: "jlawless6k",
// usersCount: 332,
// },
// {
// Id: 238,
// appName: "Sonsing",
// appId: "e579878c-7e6f-4aaa-80cf-733b00ae19b0",
// owner: "aepgrave6l",
// usersCount: 842,
// },
// {
// Id: 239,
// appName: "Stronghold",
// appId: "1ce6bcf6-7939-493e-a58a-81e2261a42fa",
// owner: "hbrandhardy6m",
// usersCount: 487,
// },
// {
// Id: 240,
// appName: "Fintone",
// appId: "9c39266b-0e57-43b0-8a99-bca7783bf091",
// owner: "eseath6n",
// usersCount: 84,
// },
// {
// Id: 241,
// appName: "Holdlamis",
// appId: "c8f16a8c-b52e-4769-8204-77722e58f239",
// owner: "akrol6o",
// usersCount: 473,
// },
// {
// Id: 242,
// appName: "Stringtough",
// appId: "8b92a26a-9d0f-4f5a-b269-ea12970451f9",
// owner: "lbiss6p",
// usersCount: 906,
// },
// {
// Id: 243,
// appName: "Bitwolf",
// appId: "e6d7a401-c9f0-422f-bb07-c445dcdddfc2",
// owner: "pvalentetti6q",
// usersCount: 753,
// },
// {
// Id: 244,
// appName: "Subin",
// appId: "3e5d1d2f-196c-4729-9e0c-30093921bfd2",
// owner: "rlarkby6r",
// usersCount: 584,
// },
// {
// Id: 245,
// appName: "Keylex",
// appId: "5b267959-98ef-412d-9807-8703883dbe72",
// owner: "korrett6s",
// usersCount: 989,
// },
// {
// Id: 246,
// appName: "Flexidy",
// appId: "cb9435cb-ece1-4336-b45f-7f47b6ea6856",
// owner: "cscranny6t",
// usersCount: 553,
// },
// {
// Id: 247,
// appName: "Pannier",
// appId: "b6c96e9a-6825-48a6-ad82-3cb71df79a61",
// owner: "cwalework6u",
// usersCount: 245,
// },
// {
// Id: 248,
// appName: "Bigtax",
// appId: "06b51436-b77f-4fc7-9c57-e9857cae81f1",
// owner: "bshelford6v",
// usersCount: 460,
// },
// {
// Id: 249,
// appName: "Prodder",
// appId: "033d7de0-ebf1-42aa-ab62-dacb070c2a95",
// owner: "clabbati6w",
// usersCount: 862,
// },
// {
// Id: 250,
// appName: "Konklux",
// appId: "b85a1fa6-ece7-46f4-a0c9-ad7912ccc6d3",
// owner: "kbrome6x",
// usersCount: 664,
// },
// {
// Id: 251,
// appName: "Tin",
// appId: "589b7190-a9f7-4e54-9c01-91abb5fb957a",
// owner: "lkennaird6y",
// usersCount: 135,
// },
// {
// Id: 252,
// appName: "Kanlam",
// appId: "a2060690-f69d-4cdb-97f5-bd8a23feeab5",
// owner: "jwinter6z",
// usersCount: 283,
// },
// {
// Id: 253,
// appName: "Konklux",
// appId: "71308e28-1600-4078-95f5-4ebf1abbf7e7",
// owner: "sregitz70",
// usersCount: 806,
// },
// {
// Id: 254,
// appName: "Stringtough",
// appId: "9c4f1542-675c-4048-8d8a-10df1c1416f3",
// owner: "aleader71",
// usersCount: 29,
// },
// {
// Id: 255,
// appName: "Duobam",
// appId: "133ba81b-35d7-42c7-8004-2f46adfdcdc8",
// owner: "vbenard72",
// usersCount: 2,
// },
// {
// Id: 256,
// appName: "Cardify",
// appId: "b6344270-0d97-4db4-bcb2-dc8ce0650035",
// owner: "vparcell73",
// usersCount: 216,
// },
// {
// Id: 257,
// appName: "Alpha",
// appId: "fc2eb434-fbd0-4fc1-b42d-f7b3cad1f0e1",
// owner: "ahamsley74",
// usersCount: 358,
// },
// {
// Id: 258,
// appName: "Zamit",
// appId: "c1b2a263-f069-41bc-b50f-57ae97337267",
// owner: "vtomasoni75",
// usersCount: 977,
// },
// {
// Id: 259,
// appName: "Holdlamis",
// appId: "0d69866c-1a38-4f60-9ccd-71c0edde42c9",
// owner: "jtarbard76",
// usersCount: 426,
// },
// {
// Id: 260,
// appName: "Andalax",
// appId: "cdf473ad-487b-4331-8628-5b149468fd42",
// owner: "imutter77",
// usersCount: 650,
// },
// {
// Id: 261,
// appName: "Stringtough",
// appId: "bc831532-2d71-4c2a-b105-1576b11f7fa5",
// owner: "cnary78",
// usersCount: 109,
// },
// {
// Id: 262,
// appName: "Ronstring",
// appId: "387cc095-608a-422f-a526-f523357ea4e7",
// owner: "hlandells79",
// usersCount: 269,
// },
// {
// Id: 263,
// appName: "Overhold",
// appId: "ecad8fe9-3af5-45ae-9342-6b0eb35f56ad",
// owner: "hkincade7a",
// usersCount: 435,
// },
// {
// Id: 264,
// appName: "Voltsillam",
// appId: "87ceff9c-23cc-41ad-bc31-913122f8740d",
// owner: "ogreville7b",
// usersCount: 921,
// },
// {
// Id: 265,
// appName: "Prodder",
// appId: "14d734c3-1154-4218-b0b2-f8c3250edff6",
// owner: "dyellowlee7c",
// usersCount: 837,
// },
// {
// Id: 266,
// appName: "Prodder",
// appId: "9e944584-e64d-4212-a778-4ae0cf11cca6",
// owner: "mguyot7d",
// usersCount: 828,
// },
// {
// Id: 267,
// appName: "Kanlam",
// appId: "05b59e73-44aa-4427-995a-125a61e83b4e",
// owner: "cfarrants7e",
// usersCount: 247,
// },
// {
// Id: 268,
// appName: "Zaam-Dox",
// appId: "d94db5c2-81f3-4b46-b8f7-7cf22f25b9fe",
// owner: "edaens7f",
// usersCount: 68,
// },
// {
// Id: 269,
// appName: "Hatity",
// appId: "45b31483-c85c-43ff-8edf-690c3d0880c4",
// owner: "atiler7g",
// usersCount: 372,
// },
// {
// Id: 270,
// appName: "Tresom",
// appId: "3736e5c4-69d9-45c4-87ef-d8bec5c51768",
// owner: "jrosevear7h",
// usersCount: 277,
// },
// {
// Id: 271,
// appName: "Bitchip",
// appId: "f6f907b7-6e3a-4dca-8a7c-7eed3e5005c5",
// owner: "thigounet7i",
// usersCount: 79,
// },
// {
// Id: 272,
// appName: "Redhold",
// appId: "999e8848-76e1-4050-800e-5f4ec9c8f6f6",
// owner: "llaweles7j",
// usersCount: 731,
// },
// {
// Id: 273,
// appName: "Tres-Zap",
// appId: "7e6b872c-d4f2-4ee5-b59f-a3ff11c11627",
// owner: "jiacovozzo7k",
// usersCount: 324,
// },
// {
// Id: 274,
// appName: "Lotlux",
// appId: "753af13f-a3c2-4dbe-9e83-bf1633f3d1d7",
// owner: "tmarie7l",
// usersCount: 2,
// },
// {
// Id: 275,
// appName: "Pannier",
// appId: "3db3ea00-a8de-40dd-9517-b8c18c69d4f3",
// owner: "ebrisard7m",
// usersCount: 553,
// },
// {
// Id: 276,
// appName: "<NAME>",
// appId: "284d7281-d63c-4e6b-a633-8b759638da92",
// owner: "shunnywell7n",
// usersCount: 970,
// },
// {
// Id: 277,
// appName: "Span",
// appId: "d3aeeed9-e557-46d9-96d6-a9cbb769c013",
// owner: "areyson7o",
// usersCount: 950,
// },
// {
// Id: 278,
// appName: "Prodder",
// appId: "9076c15c-beb7-4831-98ba-c99878a9e3d8",
// owner: "ctildesley7p",
// usersCount: 802,
// },
// {
// Id: 279,
// appName: "Sonsing",
// appId: "fbc5436c-919b-42c8-90e5-d9fc2da1607c",
// owner: "ccurlis7q",
// usersCount: 102,
// },
// {
// Id: 280,
// appName: "Overhold",
// appId: "529615c8-1017-4ae5-b6e6-380e4f3504ce",
// owner: "awonham7r",
// usersCount: 179,
// },
// {
// Id: 281,
// appName: "Job",
// appId: "77ad17b9-6bdf-46d8-bcc4-f601f5445915",
// owner: "aarkil7s",
// usersCount: 69,
// },
// {
// Id: 282,
// appName: "Ventosanzap",
// appId: "c9ceb5ef-ea89-4f1c-89b2-26bf2b4f6ca8",
// owner: "spizzey7t",
// usersCount: 78,
// },
// {
// Id: 283,
// appName: "Tempsoft",
// appId: "b4150cef-7a4a-4e5f-ac62-bf31a9a3176f",
// owner: "kcudiff7u",
// usersCount: 596,
// },
// {
// Id: 284,
// appName: "Zathin",
// appId: "b7adf7bb-c2ed-402d-acaa-806e1de83623",
// owner: "efairlem7v",
// usersCount: 839,
// },
// {
// Id: 285,
// appName: "Latlux",
// appId: "12851191-ea89-484e-a980-894a9ddf9824",
// owner: "bmckeighan7w",
// usersCount: 321,
// },
// {
// Id: 286,
// appName: "Bitchip",
// appId: "52aae5b4-b9a7-4b70-a86b-965c7dbfbd52",
// owner: "aphalp7x",
// usersCount: 910,
// },
// {
// Id: 287,
// appName: "It",
// appId: "dce2d0c0-f6d2-40bf-adf8-741b31d16c81",
// owner: "sdowdell7y",
// usersCount: 697,
// },
// {
// Id: 288,
// appName: "Treeflex",
// appId: "1b92a17d-66a3-4456-b28a-2460f957ee76",
// owner: "dpietranek7z",
// usersCount: 73,
// },
// {
// Id: 289,
// appName: "Quo Lux",
// appId: "633bc395-a2e9-440c-971b-87b06e0fd3e7",
// owner: "ktoplin80",
// usersCount: 478,
// },
// {
// Id: 290,
// appName: "Wrapsafe",
// appId: "4edb3340-f2b8-47dc-8c5e-b657703e096d",
// owner: "tmeadway81",
// usersCount: 469,
// },
// {
// Id: 291,
// appName: "Fix San",
// appId: "6abcb989-6e45-4a07-b9c4-1806d60cc4c5",
// owner: "lingram82",
// usersCount: 300,
// },
// {
// Id: 292,
// appName: "Stronghold",
// appId: "d24c7714-e7b1-4a4a-9b9b-0b801670bbae",
// owner: "mbourhill83",
// usersCount: 720,
// },
// {
// Id: 293,
// appName: "Home Ing",
// appId: "a2ceac90-8bc3-4636-a030-f6eb00322d1c",
// owner: "cbendelow84",
// usersCount: 476,
// },
// {
// Id: 294,
// appName: "Daltfresh",
// appId: "c959c693-bd46-40e0-8aeb-3882842fa26f",
// owner: "rgeram85",
// usersCount: 325,
// },
// {
// Id: 295,
// appName: "Prodder",
// appId: "08f9cf19-7980-44f9-86fb-4cd40a5fde08",
// owner: "lbrimilcombe86",
// usersCount: 622,
// },
// {
// Id: 296,
// appName: "Flowdesk",
// appId: "88b85a0c-b01a-44f1-85e3-17d45cff7c5a",
// owner: "eskains87",
// usersCount: 833,
// },
// {
// Id: 297,
// appName: "Lotstring",
// appId: "85256982-c0d9-4191-804c-cdad2ccc2a02",
// owner: "oblenkharn88",
// usersCount: 659,
// },
// {
// Id: 298,
// appName: "Duobam",
// appId: "2fba55cf-fb8a-40e4-bd68-4a255630f885",
// owner: "ddow89",
// usersCount: 415,
// },
// {
// Id: 299,
// appName: "Trippledex",
// appId: "9a9874e0-ae5a-4727-b916-51b65dbb6511",
// owner: "agiberd8a",
// usersCount: 77,
// },
// {
// Id: 300,
// appName: "Viva",
// appId: "068b6af2-9107-48d3-83f6-4ca383a79709",
// owner: "sfrancescoccio8b",
// usersCount: 473,
// },
// {
// Id: 301,
// appName: "Temp",
// appId: "d4a85f9e-6d59-4861-b916-1c4df67f71ba",
// owner: "hjinks8c",
// usersCount: 544,
// },
// {
// Id: 302,
// appName: "Kanlam",
// appId: "352ac1ea-63a2-472b-b620-4d6a53bce6a3",
// owner: "rcraker8d",
// usersCount: 992,
// },
// {
// Id: 303,
// appName: "Sonair",
// appId: "ebb1a5d7-5b36-4932-992f-2637c8cc0ae0",
// owner: "fdalgetty8e",
// usersCount: 883,
// },
// {
// Id: 304,
// appName: "Konklux",
// appId: "415f864f-423c-4831-8544-3089b4c8a0fb",
// owner: "lcottham8f",
// usersCount: 771,
// },
// {
// Id: 305,
// appName: "Alpha",
// appId: "55d250bc-74b2-4039-9c0c-e813502ed9be",
// owner: "gvonoertzen8g",
// usersCount: 973,
// },
// {
// Id: 306,
// appName: "Job",
// appId: "8000c1f1-0295-435c-9552-234f05b4ab1c",
// owner: "cbanat8h",
// usersCount: 485,
// },
// {
// Id: 307,
// appName: "Andalax",
// appId: "99961f3a-eca5-41ad-9614-9ddfd7dbcf0f",
// owner: "ffishenden8i",
// usersCount: 276,
// },
// {
// Id: 308,
// appName: "Latlux",
// appId: "64228e66-7f69-4e08-a97d-94fa42c6883e",
// owner: "tgladbeck8j",
// usersCount: 771,
// },
// {
// Id: 309,
// appName: "Lotstring",
// appId: "d93c5aae-a597-4bae-9df1-c861d221d674",
// owner: "ffarfoot8k",
// usersCount: 290,
// },
// {
// Id: 310,
// appName: "Ventosanzap",
// appId: "d773b78f-ef7c-4580-a96c-544d0175c652",
// owner: "fjedraszek8l",
// usersCount: 624,
// },
// {
// Id: 311,
// appName: "Sonair",
// appId: "9c07d11e-bd7d-40f3-ab69-c070ecc4f161",
// owner: "gingledew8m",
// usersCount: 983,
// },
// {
// Id: 312,
// appName: "Sub-Ex",
// appId: "242613e0-54e7-4bae-b128-eaa3e36bef9b",
// owner: "anunson8n",
// usersCount: 789,
// },
// {
// Id: 313,
// appName: "Tin",
// appId: "875db7a2-bc42-426c-999b-6b4dc461c5ed",
// owner: "agwillym8o",
// usersCount: 185,
// },
// {
// Id: 314,
// appName: "Quo Lux",
// appId: "84b66738-fcd9-4103-87ec-568b1a7f166f",
// owner: "imarrion8p",
// usersCount: 498,
// },
// {
// Id: 315,
// appName: "Hatity",
// appId: "01e0a93f-da2d-4ded-bcf3-6bb4579486e8",
// owner: "pgaineofengland8q",
// usersCount: 620,
// },
// {
// Id: 316,
// appName: "Pannier",
// appId: "4f8e9fa0-40b5-4a6e-ae76-bbf9125c7102",
// owner: "charrinson8r",
// usersCount: 609,
// },
// {
// Id: 317,
// appName: "Trippledex",
// appId: "b2a37421-06ab-4ca1-b095-df53349af729",
// owner: "modowling8s",
// usersCount: 921,
// },
// {
// Id: 318,
// appName: "<NAME>",
// appId: "d06f15cf-5823-4868-82c9-26d1ad0f9a71",
// owner: "stheodoris8t",
// usersCount: 879,
// },
// {
// Id: 319,
// appName: "Zathin",
// appId: "65070f1e-1507-4aeb-9fb6-bca5cf6a5a18",
// owner: "cbirdfield8u",
// usersCount: 764,
// },
// {
// Id: 320,
// appName: "Fixflex",
// appId: "104cdee1-6bed-4400-b73e-464f49b1c0e6",
// owner: "warghent8v",
// usersCount: 151,
// },
// {
// Id: 321,
// appName: "Hatity",
// appId: "ede975d7-b1f7-49d0-a8df-b018ff2ea92c",
// owner: "rheavens8w",
// usersCount: 449,
// },
// {
// Id: 322,
// appName: "Fix San",
// appId: "4dc11d2c-b5af-4047-aecf-43e3367c7713",
// owner: "smcbratney8x",
// usersCount: 423,
// },
// {
// Id: 323,
// appName: "Solarbreeze",
// appId: "2f7c3392-3ef0-4ac7-9fee-894c8a5ae971",
// owner: "teagling8y",
// usersCount: 203,
// },
// {
// Id: 324,
// appName: "Y-Solowarm",
// appId: "4433bc5d-b08f-4915-a86b-4703f83f0be0",
// owner: "kclarae8z",
// usersCount: 508,
// },
// {
// Id: 325,
// appName: "Treeflex",
// appId: "14cfbfac-cf3d-4c20-8f1d-a6524a72c506",
// owner: "ceirwin90",
// usersCount: 443,
// },
// {
// Id: 326,
// appName: "Bytecard",
// appId: "87c6d8cb-bff0-4062-9cb8-b6b5807a43ea",
// owner: "kgingel91",
// usersCount: 806,
// },
// {
// Id: 327,
// appName: "Zathin",
// appId: "8cc44125-0451-44f5-8dd1-cc3bf9693689",
// owner: "rhacun92",
// usersCount: 84,
// },
// {
// Id: 328,
// appName: "Span",
// appId: "7afc8f7f-896e-45d7-a5ca-6d5797add6b4",
// owner: "fheinemann93",
// usersCount: 991,
// },
// {
// Id: 329,
// appName: "Fintone",
// appId: "d00ac9c3-a263-413d-b63e-84bbe842466c",
// owner: "atomson94",
// usersCount: 573,
// },
// {
// Id: 330,
// appName: "Regrant",
// appId: "2fb8805c-a341-417a-8ab0-c04cf720cd39",
// owner: "ekunze95",
// usersCount: 692,
// },
// {
// Id: 331,
// appName: "Latlux",
// appId: "1a545b12-e6ba-49ed-80e1-47c873293226",
// owner: "mmunsey96",
// usersCount: 13,
// },
// {
// Id: 332,
// appName: "Cardify",
// appId: "32dc5c8e-3416-400e-a306-075083eb3475",
// owner: "aclynman97",
// usersCount: 398,
// },
// {
// Id: 333,
// appName: "Transcof",
// appId: "c395f22e-c430-4e8a-a4cd-3e0cad00f4a8",
// owner: "jdove98",
// usersCount: 757,
// },
// {
// Id: 334,
// appName: "Y-Solowarm",
// appId: "bbdb121b-4412-4fe3-afb9-6f862b6b6e4c",
// owner: "stoomer99",
// usersCount: 855,
// },
// {
// Id: 335,
// appName: "Tresom",
// appId: "92396979-1038-4cd3-bd14-ca0229ed6435",
// owner: "bdenington9a",
// usersCount: 444,
// },
// {
// Id: 336,
// appName: "Viva",
// appId: "a25e18f2-7fdd-45c0-8fe6-ee4cfa75c785",
// owner: "atitt9b",
// usersCount: 16,
// },
// {
// Id: 337,
// appName: "Aerified",
// appId: "bfd9a76f-adae-4a36-bbde-c5a19a6f585c",
// owner: "acuschieri9c",
// usersCount: 379,
// },
// {
// Id: 338,
// appName: "Solarbreeze",
// appId: "90b92c5d-10ce-401a-a7cb-ba0e8e2bca71",
// owner: "kmckinstry9d",
// usersCount: 128,
// },
// {
// Id: 339,
// appName: "Rank",
// appId: "82f25b5d-e5a0-45f1-9b35-a3d7984d790c",
// owner: "rwinchester9e",
// usersCount: 308,
// },
// {
// Id: 340,
// appName: "Matsoft",
// appId: "fc829f02-b6d6-4f66-a117-4f025a0ab543",
// owner: "ckohrsen9f",
// usersCount: 202,
// },
// {
// Id: 341,
// appName: "Cardguard",
// appId: "2c773be0-6f25-42b9-b3f3-1a72699a6e95",
// owner: "amattingley9g",
// usersCount: 78,
// },
// {
// Id: 342,
// appName: "Y-find",
// appId: "6169e3e6-eadf-4113-85cd-c951f3a599a4",
// owner: "tedsell9h",
// usersCount: 875,
// },
// {
// Id: 343,
// appName: "Latlux",
// appId: "a9d0b22e-ac1a-4d0c-9745-2658e50d6217",
// owner: "cmoyer9i",
// usersCount: 62,
// },
// {
// Id: 344,
// appName: "Transcof",
// appId: "891ec004-6e82-4dce-9ad5-4b80d19fb5b0",
// owner: "ajarad9j",
// usersCount: 69,
// },
// {
// Id: 345,
// appName: "Sonair",
// appId: "7da28f77-d315-4371-ba42-56bdc2bf6208",
// owner: "amalser9k",
// usersCount: 369,
// },
// {
// Id: 346,
// appName: "Viva",
// appId: "73cfbee4-0d0b-408e-8bbb-fc4e366b0e78",
// owner: "bboulde9l",
// usersCount: 558,
// },
// {
// Id: 347,
// appName: "Prodder",
// appId: "b219257d-ea84-4ace-8382-01a753f3af75",
// owner: "kmilmith9m",
// usersCount: 637,
// },
// {
// Id: 348,
// appName: "Daltfresh",
// appId: "034cd57f-841c-4f17-ad1f-1635c819d37d",
// owner: "ptuting9n",
// usersCount: 303,
// },
// {
// Id: 349,
// appName: "Voltsillam",
// appId: "f02be9c0-ee82-47d8-9bbf-b8a8324013d9",
// owner: "hmcgaw9o",
// usersCount: 603,
// },
// {
// Id: 350,
// appName: "Tempsoft",
// appId: "fb38c46d-80a9-4002-ba68-26fe96df69d7",
// owner: "fcharteris9p",
// usersCount: 656,
// },
// {
// Id: 351,
// appName: "Flexidy",
// appId: "1b060225-9463-4ccc-b4e6-e607c567663c",
// owner: "arilings9q",
// usersCount: 635,
// },
// {
// Id: 352,
// appName: "Cardify",
// appId: "b3bbe9d9-57e5-48c3-aa5f-a0661abae98e",
// owner: "gcauthra9r",
// usersCount: 61,
// },
// {
// Id: 353,
// appName: "Vagram",
// appId: "14ff8127-b297-4321-b433-94a4f7d2cc35",
// owner: "tmassot9s",
// usersCount: 291,
// },
// {
// Id: 354,
// appName: "Otcom",
// appId: "a392e955-3635-469a-be65-65895b025b17",
// owner: "sbraiden9t",
// usersCount: 732,
// },
// {
// Id: 355,
// appName: "Span",
// appId: "25bbfeca-97a9-4ba5-a785-3ee35c0dff3a",
// owner: "cbaldetti9u",
// usersCount: 673,
// },
// {
// Id: 356,
// appName: "Tempsoft",
// appId: "3ea02890-cca2-480c-8e9e-24938e12d549",
// owner: "ipaulino9v",
// usersCount: 590,
// },
// {
// Id: 357,
// appName: "Greenlam",
// appId: "a5bddc74-af8b-436b-b76b-4b9ccb475e46",
// owner: "wsimonin9w",
// usersCount: 463,
// },
// {
// Id: 358,
// appName: "Cardify",
// appId: "c6aa3d4d-a702-43d6-b24a-df05570c188b",
// owner: "spimblotte9x",
// usersCount: 350,
// },
// {
// Id: 359,
// appName: "Stim",
// appId: "6d867f6e-15b7-408e-a818-e952b1843cf0",
// owner: "asibly9y",
// usersCount: 378,
// },
// {
// Id: 360,
// appName: "Quo Lux",
// appId: "e932b3c9-b9cd-4e11-8dd2-d5e4526071ee",
// owner: "vmcgiven9z",
// usersCount: 626,
// },
// {
// Id: 361,
// appName: "Daltfresh",
// appId: "1a467927-b3db-4512-a995-4d2d7e086269",
// owner: "cmcclarya0",
// usersCount: 160,
// },
// {
// Id: 362,
// appName: "Transcof",
// appId: "58afbef1-5c90-410c-9141-2b0b75db882a",
// owner: "dogelbea1",
// usersCount: 104,
// },
// {
// Id: 363,
// appName: "Hatity",
// appId: "618b5ba8-a7d6-43ec-b87c-b53226db8832",
// owner: "tmelloia2",
// usersCount: 335,
// },
// {
// Id: 364,
// appName: "Alphazap",
// appId: "fd087eee-9db0-4363-ba77-56475b4145fa",
// owner: "lspensa3",
// usersCount: 632,
// },
// {
// Id: 365,
// appName: "Aerified",
// appId: "053db590-2a35-4894-b757-ac8514ca0935",
// owner: "mgullefanta4",
// usersCount: 690,
// },
// {
// Id: 366,
// appName: "Cardguard",
// appId: "972e9dd6-6aff-42d4-b7c7-8bbb4e841f95",
// owner: "bkenwarda5",
// usersCount: 319,
// },
// {
// Id: 367,
// appName: "Konklab",
// appId: "96f1b0cb-35cf-4c68-ae0d-bd5ccb82a055",
// owner: "ckidneya6",
// usersCount: 501,
// },
// {
// Id: 368,
// appName: "Opela",
// appId: "b3cc309c-eecf-4f3e-af78-13ff85560eb3",
// owner: "sgianillia7",
// usersCount: 813,
// },
// {
// Id: 369,
// appName: "Y-find",
// appId: "dde3d12e-29d3-4c56-8854-4e4fe30b75b4",
// owner: "hlotzea8",
// usersCount: 738,
// },
// {
// Id: 370,
// appName: "Zoolab",
// appId: "02c4cf99-ce92-499a-9a89-231ed3d76a83",
// owner: "lmckeggiea9",
// usersCount: 66,
// },
// {
// Id: 371,
// appName: "Bigtax",
// appId: "7e5e590f-377f-4772-97b8-52e2a479f33c",
// owner: "sfairlemaa",
// usersCount: 689,
// },
// {
// Id: 372,
// appName: "Y-find",
// appId: "2bd52f43-3d4a-4f53-908f-dcb95cdfe31e",
// owner: "aclarkewilliamsab",
// usersCount: 123,
// },
// {
// Id: 373,
// appName: "Biodex",
// appId: "7df1339b-1c19-4997-aa2b-da9306aebf09",
// owner: "alittefairac",
// usersCount: 671,
// },
// {
// Id: 374,
// appName: "Konklux",
// appId: "26fd72d1-1124-4e9e-86f1-54e5f1d75037",
// owner: "ocrightenad",
// usersCount: 935,
// },
// {
// Id: 375,
// appName: "Fixflex",
// appId: "d918e532-7280-4352-ae6a-71be0d844bac",
// owner: "sarmatageae",
// usersCount: 767,
// },
// {
// Id: 376,
// appName: "Vagram",
// appId: "dd3515af-ef72-4af1-8ba6-4c4eb87ae436",
// owner: "eadaoaf",
// usersCount: 943,
// },
// {
// Id: 377,
// appName: "Cookley",
// appId: "3ef5ff0a-cc9c-4577-b89f-409180f6b53b",
// owner: "aadessag",
// usersCount: 83,
// },
// {
// Id: 378,
// appName: "Lotstring",
// appId: "e79edf4d-ce4e-44f0-8f8e-ad476ea6c0c4",
// owner: "smulvaghah",
// usersCount: 207,
// },
// {
// Id: 379,
// appName: "Hatity",
// appId: "d7c31d90-7a63-45b5-b6fb-19dcce06c23d",
// owner: "cambrodiai",
// usersCount: 141,
// },
// {
// Id: 380,
// appName: "Prodder",
// appId: "82de7aeb-04f1-46de-8ed5-62d3f3241b34",
// owner: "odebankeaj",
// usersCount: 933,
// },
// {
// Id: 381,
// appName: "Span",
// appId: "76ec8432-055a-45dc-83c8-807ce6da91e0",
// owner: "ccorballyak",
// usersCount: 250,
// },
// {
// Id: 382,
// appName: "Bigtax",
// appId: "7bfe3e61-84fb-459a-8562-96957e516b0c",
// owner: "bbroggioal",
// usersCount: 703,
// },
// {
// Id: 383,
// appName: "Otcom",
// appId: "525747fd-e071-4702-9061-909623ce168b",
// owner: "asawkinsam",
// usersCount: 514,
// },
// {
// Id: 384,
// appName: "Hatity",
// appId: "91c51b82-db92-412e-90fe-0dcb1d4c17db",
// owner: "ahampsteadan",
// usersCount: 894,
// },
// {
// Id: 385,
// appName: "Trippledex",
// appId: "26b2070b-a2d2-4644-ac66-98cb5426cff0",
// owner: "amcveeao",
// usersCount: 222,
// },
// {
// Id: 386,
// appName: "Cookley",
// appId: "5f44ebf1-2196-451d-9366-f92028cdfa55",
// owner: "pcolumbellap",
// usersCount: 509,
// },
// {
// Id: 387,
// appName: "Ventosanzap",
// appId: "6601f5e7-825b-4db5-a194-d902324259cb",
// owner: "estycheaq",
// usersCount: 759,
// },
// {
// Id: 388,
// appName: "Zontrax",
// appId: "b8b6ede9-e19e-49c9-88a1-4bb901b4c5fb",
// owner: "fwillowbyar",
// usersCount: 818,
// },
// {
// Id: 389,
// appName: "Latlux",
// appId: "2f98123f-4deb-4977-94e3-7a9aa7eb593d",
// owner: "spiddlehintonas",
// usersCount: 998,
// },
// {
// Id: 390,
// appName: "Aerified",
// appId: "7eaad593-f9e2-445a-b5ba-680de70a0443",
// owner: "tluigiat",
// usersCount: 275,
// },
// {
// Id: 391,
// appName: "Zoolab",
// appId: "594b2a67-13af-4e84-b465-dadfe00c944a",
// owner: "ohallaganau",
// usersCount: 512,
// },
// {
// Id: 392,
// appName: "Voltsillam",
// appId: "1aa1a7f0-0dc6-4e13-8304-c55e337f531e",
// owner: "khallutav",
// usersCount: 47,
// },
// {
// Id: 393,
// appName: "Bamity",
// appId: "ba39f0da-e397-461b-86f2-6f98747cea2b",
// owner: "wohmaw",
// usersCount: 961,
// },
// {
// Id: 394,
// appName: "Lotstring",
// appId: "4852f812-d349-49a0-8abf-7fbabe19a402",
// owner: "singlissax",
// usersCount: 922,
// },
// {
// Id: 395,
// appName: "Tres-Zap",
// appId: "bd28aba7-b69c-4856-b4cd-996a8348c350",
// owner: "espelsburyay",
// usersCount: 83,
// },
// {
// Id: 396,
// appName: "Solarbreeze",
// appId: "1d1cde97-9bfe-43bb-87b4-d598f8cf3298",
// owner: "kcaberaaz",
// usersCount: 257,
// },
// {
// Id: 397,
// appName: "Flexidy",
// appId: "b320d66b-47c4-4e1d-9fee-acc219cb28b6",
// owner: "fomullanb0",
// usersCount: 403,
// },
// {
// Id: 398,
// appName: "Prodder",
// appId: "e4f2f537-9f8e-4b12-ac9f-8d976530328a",
// owner: "wbruntjeb1",
// usersCount: 249,
// },
// {
// Id: 399,
// appName: "Matsoft",
// appId: "3b1f6f06-242c-4288-8e4d-298b7bfb166b",
// owner: "btattonb2",
// usersCount: 789,
// },
// {
// Id: 400,
// appName: "Opela",
// appId: "48fa1c7c-0fdf-462d-a22a-48046f29351e",
// owner: "llittledikeb3",
// usersCount: 316,
// },
// {
// Id: 401,
// appName: "Tres-Zap",
// appId: "dc56a6bd-c853-4439-a73d-cc4f9f27e002",
// owner: "arevensb4",
// usersCount: 856,
// },
// {
// Id: 402,
// appName: "It",
// appId: "6d044d4c-23f6-4237-b8a6-9a6a54fc3adc",
// owner: "hfatscherb5",
// usersCount: 240,
// },
// {
// Id: 403,
// appName: "Namfix",
// appId: "41b07bf9-5fdf-45b0-8be1-e0964b8df941",
// owner: "acoarserb6",
// usersCount: 899,
// },
// {
// Id: 404,
// appName: "Otcom",
// appId: "4ecb4e98-732e-42ac-8638-ef09aab85b23",
// owner: "elaxsonb7",
// usersCount: 879,
// },
// {
// Id: 405,
// appName: "Konklux",
// appId: "79dca7d5-2bb3-4d5a-854a-e9a42e0986e7",
// owner: "vmenereb8",
// usersCount: 999,
// },
// {
// Id: 406,
// appName: "Toughjoyfax",
// appId: "3fe1c27d-4a7c-4e38-95e3-d9f2cb1e251b",
// owner: "dverekerb9",
// usersCount: 879,
// },
// {
// Id: 407,
// appName: "Ventosanzap",
// appId: "b0bd0446-96c9-4f91-be33-876bd399f0a4",
// owner: "cmeineckba",
// usersCount: 774,
// },
// {
// Id: 408,
// appName: "Stringtough",
// appId: "8149f3b3-bb90-46d3-820a-ed823dcd47cd",
// owner: "kskatcherbb",
// usersCount: 118,
// },
// {
// Id: 409,
// appName: "Bamity",
// appId: "56d7eecb-743c-459a-947c-52e0570b3c9e",
// owner: "cnequestbc",
// usersCount: 755,
// },
// {
// Id: 410,
// appName: "Prodder",
// appId: "a0366248-71e4-4edc-a4ac-2a8334cb9573",
// owner: "lmckeaneybd",
// usersCount: 292,
// },
// {
// Id: 411,
// appName: "Domainer",
// appId: "5b3e9612-6fbe-4475-961f-3f1b931c2e92",
// owner: "hgeavenybe",
// usersCount: 143,
// },
// {
// Id: 412,
// appName: "Biodex",
// appId: "54de92bb-afe6-4de5-9544-8e11c2a9cbb3",
// owner: "nsibyllabf",
// usersCount: 694,
// },
// {
// Id: 413,
// appName: "Opela",
// appId: "074918e8-5b7e-4a9d-b76f-8decb26171ad",
// owner: "gduesburybg",
// usersCount: 660,
// },
// {
// Id: 414,
// appName: "Bamity",
// appId: "ee0efb5e-3e2e-4497-ab42-5b8548661e79",
// owner: "dtregearbh",
// usersCount: 310,
// },
// {
// Id: 415,
// appName: "Holdlamis",
// appId: "2e259207-fdb2-4647-93a4-5896eb9090a4",
// owner: "jhaggartybi",
// usersCount: 610,
// },
// {
// Id: 416,
// appName: "Pannier",
// appId: "1135f449-7b65-40a1-b2bb-7bcd67c17130",
// owner: "kwallmanbj",
// usersCount: 285,
// },
// {
// Id: 417,
// appName: "Aerified",
// appId: "c5320d39-80c0-4271-937f-2090ab1747fa",
// owner: "cplattsbk",
// usersCount: 416,
// },
// {
// Id: 418,
// appName: "Aerified",
// appId: "3f068153-7670-4f61-adea-473751af1d3b",
// owner: "scursonbl",
// usersCount: 159,
// },
// {
// Id: 419,
// appName: "Sub-Ex",
// appId: "59ddc3c1-a332-4a26-bc5c-94ecc4722a05",
// owner: "mlyallbm",
// usersCount: 931,
// },
// {
// Id: 420,
// appName: "Fixflex",
// appId: "73ccc163-32c5-4f74-a3f2-c0e3d6d9c27b",
// owner: "fbiancobn",
// usersCount: 844,
// },
// {
// Id: 421,
// appName: "Gembucket",
// appId: "9c478f40-07c9-4eb5-ae54-83c2ecef8351",
// owner: "pbranscombbo",
// usersCount: 694,
// },
// {
// Id: 422,
// appName: "Namfix",
// appId: "33f6b6d1-9998-4ee7-bb84-6596387ae4f1",
// owner: "jbraynebp",
// usersCount: 87,
// },
// {
// Id: 423,
// appName: "Redhold",
// appId: "7c752f4c-deee-43da-bc1e-23d978f46a07",
// owner: "dmartinsonbq",
// usersCount: 753,
// },
// {
// Id: 424,
// appName: "Transcof",
// appId: "bc9e5182-2cca-41eb-9c1b-b2d0001cb873",
// owner: "kgaviganbr",
// usersCount: 628,
// },
// {
// Id: 425,
// appName: "Y-Solowarm",
// appId: "30535ec4-2d45-4cde-af80-c1b1a8735f29",
// owner: "tcorpesbs",
// usersCount: 303,
// },
// {
// Id: 426,
// appName: "Tres-Zap",
// appId: "59c2d1b2-6f05-42bc-b86c-4c34f44ac535",
// owner: "lrobertsbt",
// usersCount: 187,
// },
// {
// Id: 427,
// appName: "Andalax",
// appId: "c16390ab-cc5d-4304-98f3-5b84f5e403aa",
// owner: "amcjerrowbu",
// usersCount: 599,
// },
// {
// Id: 428,
// appName: "Redhold",
// appId: "a6b572af-3a71-4d6c-ae74-0cba272bf986",
// owner: "ssappybv",
// usersCount: 934,
// },
// {
// Id: 429,
// appName: "Solarbreeze",
// appId: "78cebc2b-7463-446d-a634-72b203578e29",
// owner: "dfilkovbw",
// usersCount: 604,
// },
// {
// Id: 430,
// appName: "Fintone",
// appId: "7c8016b3-79b1-4df4-975b-521dcbe3fd58",
// owner: "gsunshinebx",
// usersCount: 759,
// },
// {
// Id: 431,
// appName: "Konklab",
// appId: "4b757f91-3172-4445-a3c1-4ef2855ae374",
// owner: "amcanalleyby",
// usersCount: 474,
// },
// {
// Id: 432,
// appName: "Zaam-Dox",
// appId: "c736597c-6c18-473d-8ad6-103101c7fd9c",
// owner: "glouwbz",
// usersCount: 709,
// },
// {
// Id: 433,
// appName: "Voyatouch",
// appId: "64f96f6e-ccbc-48e6-af29-4bd9be794cbd",
// owner: "snollic0",
// usersCount: 442,
// },
// {
// Id: 434,
// appName: "Kanlam",
// appId: "32f943fa-811c-4710-8644-50fb6c865991",
// owner: "kahearnec1",
// usersCount: 602,
// },
// {
// Id: 435,
// appName: "Tempsoft",
// appId: "6ec5db26-7367-4e0c-b325-4fc534eec8f6",
// owner: "ebascombc2",
// usersCount: 503,
// },
// {
// Id: 436,
// appName: "Konklux",
// appId: "ed35f837-bc6c-4c5c-a7c9-e87b7417ee8e",
// owner: "amalyc3",
// usersCount: 790,
// },
// {
// Id: 437,
// appName: "Zaam-Dox",
// appId: "9c55bbd9-2983-4ed7-adaa-046f7ac105f2",
// owner: "dclaptonc4",
// usersCount: 366,
// },
// {
// Id: 438,
// appName: "Regrant",
// appId: "28373265-c3e2-4eca-a041-6b5b00647877",
// owner: "lkarpenyac5",
// usersCount: 858,
// },
// {
// Id: 439,
// appName: "Fixflex",
// appId: "0118b1ab-9ac7-4a66-be6a-4f4117c0f891",
// owner: "dionnc6",
// usersCount: 553,
// },
// {
// Id: 440,
// appName: "Flowdesk",
// appId: "4af071b3-67c8-43fc-a0a2-cd3c75cb54ac",
// owner: "sdedomenicisc7",
// usersCount: 524,
// },
// {
// Id: 441,
// appName: "Lotstring",
// appId: "e5fe3810-d41c-4dcf-95f3-cb1812d3de66",
// owner: "rthynnc8",
// usersCount: 604,
// },
// {
// Id: 442,
// appName: "Matsoft",
// appId: "955fd3f5-bb4a-4b3a-a409-9ccedafd6b53",
// owner: "rgilesc9",
// usersCount: 400,
// },
// {
// Id: 443,
// appName: "Overhold",
// appId: "9ead225a-d5d7-4d95-bc0e-d252e7c3c789",
// owner: "gboocockca",
// usersCount: 418,
// },
// {
// Id: 444,
// appName: "Latlux",
// appId: "501d5a71-dad9-4042-81dd-da424eff7f99",
// owner: "nwoodhamcb",
// usersCount: 106,
// },
// {
// Id: 445,
// appName: "Sonair",
// appId: "e006eb11-424a-46f1-ac01-35434e58dc16",
// owner: "ctrusslercc",
// usersCount: 521,
// },
// {
// Id: 446,
// appName: "Ronstring",
// appId: "7b57a743-fb3b-4047-8193-03e8cbdb3cad",
// owner: "aavoncd",
// usersCount: 814,
// },
// {
// Id: 447,
// appName: "Tampflex",
// appId: "1d5e8b81-84b8-47b1-a927-9dde9452e3bf",
// owner: "dpawnsfordce",
// usersCount: 159,
// },
// {
// Id: 448,
// appName: "Wrapsafe",
// appId: "7206803b-88c4-4dfb-a4e9-fbd8c2debf08",
// owner: "tcolliarcf",
// usersCount: 504,
// },
// {
// Id: 449,
// appName: "Vagram",
// appId: "9bf9223a-9f0a-45fc-ac88-9aea45451b85",
// owner: "ogrigoryevcg",
// usersCount: 105,
// },
// {
// Id: 450,
// appName: "Bytecard",
// appId: "dbf8e63b-88bb-488e-b1d5-a114a11f6600",
// owner: "rmitrovicch",
// usersCount: 7,
// },
// {
// Id: 451,
// appName: "Holdlamis",
// appId: "cac576f2-0b09-4679-a47c-87b94a2db767",
// owner: "frivalandci",
// usersCount: 315,
// },
// {
// Id: 452,
// appName: "Latlux",
// appId: "2eb68a3f-d12f-4f23-8f82-882fe411d53b",
// owner: "mbewlycj",
// usersCount: 346,
// },
// {
// Id: 453,
// appName: "Ronstring",
// appId: "194be18c-c628-44cd-a579-c57cb3bf6dcf",
// owner: "sfarfootck",
// usersCount: 894,
// },
// {
// Id: 454,
// appName: "Bamity",
// appId: "aca93d21-08e4-4ffc-9e75-da967bcb9172",
// owner: "rspositocl",
// usersCount: 253,
// },
// {
// Id: 455,
// appName: "Regrant",
// appId: "d97425ef-fb6c-4858-a873-23bc400ecc7a",
// owner: "jmacdermidcm",
// usersCount: 383,
// },
// {
// Id: 456,
// appName: "Lotstring",
// appId: "f8364b9d-ed2a-45fe-89e8-e09710a42591",
// owner: "mpiddletowncn",
// usersCount: 193,
// },
// {
// Id: 457,
// appName: "Trippledex",
// appId: "14dfef6f-b37f-4ab5-a94a-f022bc7859b1",
// owner: "snencico",
// usersCount: 30,
// },
// {
// Id: 458,
// appName: "Sonair",
// appId: "0f286a92-8ef6-44e4-b1dc-5ffc7d19ce36",
// owner: "ljergercp",
// usersCount: 900,
// },
// {
// Id: 459,
// appName: "Span",
// appId: "242d0594-f4e5-401f-a9bc-811ba9cb4e08",
// owner: "kblaslicq",
// usersCount: 920,
// },
// {
// Id: 460,
// appName: "Sonsing",
// appId: "52192574-0d52-4a8c-adcd-4b735fa30cc0",
// owner: "eshirtcliffecr",
// usersCount: 902,
// },
// {
// Id: 461,
// appName: "Bigtax",
// appId: "4430c9cd-39a4-4ada-a0fe-07e9161b75a8",
// owner: "lcharlesworthcs",
// usersCount: 444,
// },
// {
// Id: 462,
// appName: "Voyatouch",
// appId: "3aced254-ab93-40c1-bc6c-e794ddb6f5d3",
// owner: "jandrejevicct",
// usersCount: 53,
// },
// {
// Id: 463,
// appName: "Cardguard",
// appId: "9613e8f2-fb0b-43ac-8cf6-f5dad9a6d466",
// owner: "wsawdoncu",
// usersCount: 676,
// },
// {
// Id: 464,
// appName: "Cookley",
// appId: "3b6c8af5-4644-4754-ac64-be446c908502",
// owner: "ktweedycv",
// usersCount: 774,
// },
// {
// Id: 465,
// appName: "Pannier",
// appId: "1f5f5204-f5e8-474e-ab5d-cfa7b83e7419",
// owner: "mtregaskiscw",
// usersCount: 289,
// },
// {
// Id: 466,
// appName: "It",
// appId: "300c6754-1e34-4b3b-b8dd-1f805f3c5bb8",
// owner: "oabdycx",
// usersCount: 619,
// },
// {
// Id: 467,
// appName: "Sonair",
// appId: "36486921-1631-4509-993a-c016503dc189",
// owner: "slevingscy",
// usersCount: 950,
// },
// {
// Id: 468,
// appName: "Bigtax",
// appId: "43a04ecc-fda9-4ca9-abac-302dc5cab81d",
// owner: "qsouthwaycz",
// usersCount: 970,
// },
// {
// Id: 469,
// appName: "Duobam",
// appId: "f4301fb7-6fc3-45d6-99cb-471d5e90c729",
// owner: "udeansd0",
// usersCount: 385,
// },
// {
// Id: 470,
// appName: "Sonair",
// appId: "07784355-4fd3-4eec-bdca-4cba704e98e3",
// owner: "jschoolingd1",
// usersCount: 988,
// },
// {
// Id: 471,
// appName: "Zontrax",
// appId: "1bcd862c-dddd-48a8-8eee-1523b3879356",
// owner: "hfarreyd2",
// usersCount: 570,
// },
// {
// Id: 472,
// appName: "Domainer",
// appId: "8f7740f1-6aa2-46ed-b15c-52f47398f689",
// owner: "lbyrdd3",
// usersCount: 142,
// },
// {
// Id: 473,
// appName: "Namfix",
// appId: "163c9c42-baaa-4338-9b72-0f13b0d1a9b2",
// owner: "ebeauvaisd4",
// usersCount: 365,
// },
// {
// Id: 474,
// appName: "Fix San",
// appId: "795d1dac-a3bc-4b8e-a9c7-5ceec99adae4",
// owner: "gdecastrid5",
// usersCount: 379,
// },
// {
// Id: 475,
// appName: "Alpha",
// appId: "e5c9ce6b-088e-4cb7-9fed-7ab38236cd1d",
// owner: "asnoxilld6",
// usersCount: 60,
// },
// {
// Id: 476,
// appName: "Holdlamis",
// appId: "844018f9-6fb4-4c34-81b6-d5bcebec176a",
// owner: "rmattholied7",
// usersCount: 945,
// },
// {
// Id: 477,
// appName: "Trippledex",
// appId: "9df2c881-c3cd-40fa-8b78-4e582483a09a",
// owner: "cdollardd8",
// usersCount: 754,
// },
// {
// Id: 478,
// appName: "Opela",
// appId: "b476dd6c-5315-4a36-a1c2-e3ff7374099f",
// owner: "bbuckeridged9",
// usersCount: 307,
// },
// {
// Id: 479,
// appName: "Zaam-Dox",
// appId: "ed79ec55-6aa4-40d2-9824-df9a43d0a467",
// owner: "tdesimoneda",
// usersCount: 993,
// },
// {
// Id: 480,
// appName: "Otcom",
// appId: "168b8648-b17e-420f-9a97-4c819dd1d3fb",
// owner: "uabelsdb",
// usersCount: 93,
// },
// {
// Id: 481,
// appName: "Stringtough",
// appId: "d7417d9a-bf86-4e3c-885f-0ea9bf1eaad3",
// owner: "ocootdc",
// usersCount: 364,
// },
// {
// Id: 482,
// appName: "Viva",
// appId: "1141825c-eecb-4455-9e8b-09b801a49eec",
// owner: "mkamenardd",
// usersCount: 537,
// },
// {
// Id: 483,
// appName: "Greenlam",
// appId: "d7c37bec-06b9-4830-afde-5acef521758d",
// owner: "priallde",
// usersCount: 663,
// },
// {
// Id: 484,
// appName: "It",
// appId: "b288a23b-3dd8-4ce3-bb92-c9722d46f7cd",
// owner: "vwodhamdf",
// usersCount: 612,
// },
// {
// Id: 485,
// appName: "Lotstring",
// appId: "3203f98d-8417-4784-b287-a9b5f8b30269",
// owner: "dmatasovdg",
// usersCount: 880,
// },
// {
// Id: 486,
// appName: "Tres-Zap",
// appId: "e700905f-076f-434a-86e4-1c576fc4ef5f",
// owner: "eyewendh",
// usersCount: 394,
// },
// {
// Id: 487,
// appName: "Zoolab",
// appId: "8a4d1b95-43ae-4562-b855-e9a40d28ae36",
// owner: "ocannelldi",
// usersCount: 168,
// },
// {
// Id: 488,
// appName: "Subin",
// appId: "8ed72a23-1359-40db-a21c-20a74fc4549d",
// owner: "ctukesbydj",
// usersCount: 154,
// },
// {
// Id: 489,
// appName: "Stronghold",
// appId: "f66e531d-7d74-4da7-a14d-26036b85010e",
// owner: "hkleynermansdk",
// usersCount: 634,
// },
// {
// Id: 490,
// appName: "Temp",
// appId: "fb27d07b-e0a5-4840-a53d-586ceb90d8bd",
// owner: "otumbridgedl",
// usersCount: 220,
// },
// {
// Id: 491,
// appName: "Cardify",
// appId: "78de6b58-6a16-4a56-9c92-b589bcc962de",
// owner: "gmaffiolettidm",
// usersCount: 889,
// },
// {
// Id: 492,
// appName: "Voyatouch",
// appId: "9abb6f95-615d-4a55-a19e-4695093a19ee",
// owner: "bbasterfielddn",
// usersCount: 702,
// },
// {
// Id: 493,
// appName: "Cardguard",
// appId: "309bafb7-0d09-4415-ba33-ea30df90d9c1",
// owner: "ndeningtondo",
// usersCount: 150,
// },
// {
// Id: 494,
// appName: "Keylex",
// appId: "3b1f2ddc-068b-404c-9c03-685281e0bb47",
// owner: "soconcannondp",
// usersCount: 612,
// },
// {
// Id: 495,
// appName: "Bytecard",
// appId: "af7aaa17-5226-4d24-bfed-0fcb2c9a9157",
// owner: "acandelindq",
// usersCount: 775,
// },
// {
// Id: 496,
// appName: "Daltfresh",
// appId: "03b2e0c7-b101-410e-82db-52fb2c52c86d",
// owner: "eworksdr",
// usersCount: 548,
// },
// {
// Id: 497,
// appName: "Bamity",
// appId: "404b0743-b3e0-4d84-8109-deded8bbc741",
// owner: "blathyds",
// usersCount: 104,
// },
// {
// Id: 498,
// appName: "Zoolab",
// appId: "39a4e4aa-a317-4139-8a0e-ea9e4723c721",
// owner: "dbeamontdt",
// usersCount: 468,
// },
// {
// Id: 499,
// appName: "Konklux",
// appId: "f2e2a560-416b-435c-b4a8-9fe0c106a477",
// owner: "lmarshmandu",
// usersCount: 222,
// },
// {
// Id: 500,
// appName: "Greenlam",
// appId: "abda4c5c-e6a7-4276-a56e-a7fe7d1fdd00",
// owner: "aillwelldv",
// usersCount: 236,
// },
// {
// Id: 501,
// appName: "Subin",
// appId: "7a05f5bf-3dd0-4f9a-9968-f4b94bd13da7",
// owner: "citzkowiczdw",
// usersCount: 665,
// },
// {
// Id: 502,
// appName: "Matsoft",
// appId: "5cd45a02-3046-47f0-b5db-6cde03c9f67c",
// owner: "ggirthdx",
// usersCount: 603,
// },
// {
// Id: 503,
// appName: "Biodex",
// appId: "5a1df3fc-4ac6-4aba-891a-8923f1ad68b9",
// owner: "spercydy",
// usersCount: 427,
// },
// {
// Id: 504,
// appName: "Stim",
// appId: "4357428a-0103-4221-9fc4-349646efd3c7",
// owner: "cabbettdz",
// usersCount: 469,
// },
// {
// Id: 505,
// appName: "Quo Lux",
// appId: "fe93b93e-1837-4f1b-911c-9bb50b49d16d",
// owner: "obrume0",
// usersCount: 906,
// },
// {
// Id: 506,
// appName: "Treeflex",
// appId: "2cc2fb3c-0c7c-4a37-aad7-e72460b3a30e",
// owner: "pmeasene1",
// usersCount: 291,
// },
// {
// Id: 507,
// appName: "Alpha",
// appId: "1ea0371a-b51a-4a7c-b788-60bc27f2f236",
// owner: "kvanderveldte2",
// usersCount: 780,
// },
// {
// Id: 508,
// appName: "Holdlamis",
// appId: "8ae90cfb-929d-4d3b-ab35-3114e720f5ba",
// owner: "ccomforte3",
// usersCount: 262,
// },
// {
// Id: 509,
// appName: "Span",
// appId: "8ba38367-6507-45c3-bf71-a2be2dbe8839",
// owner: "mhartlye4",
// usersCount: 853,
// },
// {
// Id: 510,
// appName: "Overhold",
// appId: "3ef33b07-8046-4efa-b208-2e7308367255",
// owner: "mharrade5",
// usersCount: 231,
// },
// {
// Id: 511,
// appName: "Biodex",
// appId: "9db18b86-f72b-4971-9dcf-72ce2494e671",
// owner: "harmingere6",
// usersCount: 566,
// },
// {
// Id: 512,
// appName: "Daltfresh",
// appId: "d3fd7f3e-6957-481d-af01-4ad69b80248a",
// owner: "dskamelle7",
// usersCount: 808,
// },
// {
// Id: 513,
// appName: "Aerified",
// appId: "1c3d712c-f71c-42f6-b50e-d2bc99d67575",
// owner: "jwannelle8",
// usersCount: 304,
// },
// {
// Id: 514,
// appName: "Cookley",
// appId: "453de76b-a350-46f2-845e-a49a7489c8ee",
// owner: "varnsone9",
// usersCount: 319,
// },
// {
// Id: 515,
// appName: "Zathin",
// appId: "df677689-266f-4201-bd6b-de38ad0763eb",
// owner: "iammerea",
// usersCount: 851,
// },
// {
// Id: 516,
// appName: "Toughjoyfax",
// appId: "5719411b-139b-4a89-be0f-7d8793aa89af",
// owner: "tcouleseb",
// usersCount: 40,
// },
// {
// Id: 517,
// appName: "Treeflex",
// appId: "555bc31e-8ec1-417b-9c98-4254afb8b2ab",
// owner: "apayec",
// usersCount: 478,
// },
// {
// Id: 518,
// appName: "Bamity",
// appId: "fc47e70e-821b-49d9-afd1-8d91fdf9c285",
// owner: "lcolegroveed",
// usersCount: 844,
// },
// {
// Id: 519,
// appName: "<NAME>",
// appId: "e30d0417-f626-449e-8881-472b658a648b",
// owner: "hgeldertee",
// usersCount: 568,
// },
// {
// Id: 520,
// appName: "Zontrax",
// appId: "86921fa8-345c-4405-ad8f-a0891e16f4ef",
// owner: "lfrankef",
// usersCount: 436,
// },
// {
// Id: 521,
// appName: "Kanlam",
// appId: "8e812f79-53e7-4799-be0d-187f33289046",
// owner: "ehughsoneg",
// usersCount: 196,
// },
// {
// Id: 522,
// appName: "Bitchip",
// appId: "6b309f5c-09a9-4e98-946a-f56f4b9bbd7e",
// owner: "camotteh",
// usersCount: 957,
// },
// {
// Id: 523,
// appName: "Temp",
// appId: "3e6cb347-027e-41d1-8ae5-e59368dfcf8a",
// owner: "rtaxei",
// usersCount: 579,
// },
// {
// Id: 524,
// appName: "Bigtax",
// appId: "7a300f6c-38e6-4677-8428-67beed7d2817",
// owner: "zsteelej",
// usersCount: 616,
// },
// {
// Id: 525,
// appName: "Tresom",
// appId: "69ddb9e9-fc2e-4246-b23f-6bc0c69704be",
// owner: "plumoxek",
// usersCount: 356,
// },
// {
// Id: 526,
// appName: "Ventosanzap",
// appId: "05da3fa8-9663-4b08-9fb2-98b8c32adc80",
// owner: "lhardingel",
// usersCount: 24,
// },
// {
// Id: 527,
// appName: "Pannier",
// appId: "bd91c467-712a-4ba1-a80d-57b723a173a8",
// owner: "egodsilem",
// usersCount: 952,
// },
// {
// Id: 528,
// appName: "Toughjoyfax",
// appId: "3247884c-0040-4edd-badb-0677f7c6e560",
// owner: "tstuddalen",
// usersCount: 490,
// },
// {
// Id: 529,
// appName: "Bitwolf",
// appId: "d70a3640-2616-47bb-bccd-859796edf72e",
// owner: "ftysalleo",
// usersCount: 967,
// },
// {
// Id: 530,
// appName: "Y-Solowarm",
// appId: "fb7b1eb4-bc81-4fd4-90c3-587771f733ec",
// owner: "sgiacomuzziep",
// usersCount: 135,
// },
// {
// Id: 531,
// appName: "Wrapsafe",
// appId: "17f4b770-5fd5-4614-afad-30c2dd73294e",
// owner: "hhaggaseq",
// usersCount: 51,
// },
// {
// Id: 532,
// appName: "Lotstring",
// appId: "b007e78f-5d1a-4b80-a2d3-6b37dfe6125e",
// owner: "lleadbeaterer",
// usersCount: 177,
// },
// {
// Id: 533,
// appName: "Matsoft",
// appId: "eff75052-b6e5-4d3f-b4e0-dca08870a790",
// owner: "cdaryes",
// usersCount: 259,
// },
// {
// Id: 534,
// appName: "Andalax",
// appId: "d47e41e1-b103-46db-83b7-c651cace204c",
// owner: "eflecknellet",
// usersCount: 340,
// },
// {
// Id: 535,
// appName: "Pannier",
// appId: "c8749d70-65b7-4188-8cca-24eae39f3121",
// owner: "ffenicheu",
// usersCount: 516,
// },
// {
// Id: 536,
// appName: "Rank",
// appId: "1993e6ae-5732-4438-ae73-475b71aff68b",
// owner: "tbirtleev",
// usersCount: 255,
// },
// {
// Id: 537,
// appName: "Gembucket",
// appId: "7cf0ba32-18f7-4a83-88fd-7e12d48e7fe0",
// owner: "dgoingew",
// usersCount: 1,
// },
// {
// Id: 538,
// appName: "Voltsillam",
// appId: "9eff368a-7605-4cfe-acdd-541a7bb2c1c0",
// owner: "bdesouzaex",
// usersCount: 443,
// },
// {
// Id: 539,
// appName: "Fixflex",
// appId: "a1892fc7-54ff-4539-ab83-326a7abf8157",
// owner: "dkelley",
// usersCount: 29,
// },
// {
// Id: 540,
// appName: "Keylex",
// appId: "43180346-ca02-4ed1-ae7c-0d69176eacab",
// owner: "hsambathez",
// usersCount: 200,
// },
// {
// Id: 541,
// appName: "Zontrax",
// appId: "56d09301-fa5e-4be8-a400-756a7f6c91b0",
// owner: "sdymentf0",
// usersCount: 909,
// },
// {
// Id: 542,
// appName: "Opela",
// appId: "3fccd31f-677d-42f6-99a0-a34d737609ca",
// owner: "hmcgettrickf1",
// usersCount: 291,
// },
// {
// Id: 543,
// appName: "Gembucket",
// appId: "f4ee716b-0d01-41c2-87a9-074bf9bd57f9",
// owner: "aroganf2",
// usersCount: 671,
// },
// {
// Id: 544,
// appName: "Keylex",
// appId: "a1ed004b-9cf8-4379-9ef6-280b38612d11",
// owner: "fputtockf3",
// usersCount: 550,
// },
// {
// Id: 545,
// appName: "Flexidy",
// appId: "ba69a733-82dd-40b5-8882-fd73b758506d",
// owner: "cblinckof4",
// usersCount: 984,
// },
// {
// Id: 546,
// appName: "Asoka",
// appId: "9fb4c496-f527-4eae-b902-5e04a1adf7d4",
// owner: "rbattillf5",
// usersCount: 647,
// },
// {
// Id: 547,
// appName: "Veribet",
// appId: "a07903ca-1c0b-4c26-a0da-d797a54cb693",
// owner: "rbengocheaf6",
// usersCount: 897,
// },
// {
// Id: 548,
// appName: "Span",
// appId: "eb4edf44-fdc9-49a1-8590-b9ecffc3972e",
// owner: "cnickelsf7",
// usersCount: 254,
// },
// {
// Id: 549,
// appName: "Toughjoyfax",
// appId: "2af476c9-2c2a-4a06-bad7-2ffb6fce8553",
// owner: "bvillagef8",
// usersCount: 436,
// },
// {
// Id: 550,
// appName: "Daltfresh",
// appId: "37d36576-1b9e-4478-9540-0e55cbd03d54",
// owner: "gdattef9",
// usersCount: 452,
// },
// {
// Id: 551,
// appName: "Flexidy",
// appId: "0bc3ce67-c5e1-4dd2-9c5f-4c5673ec9314",
// owner: "ljedrzejfa",
// usersCount: 731,
// },
// {
// Id: 552,
// appName: "Biodex",
// appId: "7d43ba69-f326-41e9-b943-20016bf62928",
// owner: "vmarshfieldfb",
// usersCount: 82,
// },
// {
// Id: 553,
// appName: "Redhold",
// appId: "e1578116-a70f-480e-918b-ff13d71c72df",
// owner: "iisardfc",
// usersCount: 823,
// },
// {
// Id: 554,
// appName: "Ronstring",
// appId: "d4d1198a-265d-43d3-afab-959dafbcb00b",
// owner: "wthunnercleffd",
// usersCount: 251,
// },
// {
// Id: 555,
// appName: "Zoolab",
// appId: "3779ef6d-c0bc-442b-979e-35e214338bb3",
// owner: "gtwiggfe",
// usersCount: 976,
// },
// {
// Id: 556,
// appName: "Treeflex",
// appId: "f97bea5a-8c95-440a-98a1-0c2ecc02e744",
// owner: "kmathieuff",
// usersCount: 928,
// },
// {
// Id: 557,
// appName: "Job",
// appId: "b66be144-730e-400a-bffc-31564570f2b5",
// owner: "rmcmichanfg",
// usersCount: 183,
// },
// {
// Id: 558,
// appName: "Konklab",
// appId: "6a477288-8309-4a34-99ef-d9fffc36f270",
// owner: "cblunderfieldfh",
// usersCount: 74,
// },
// {
// Id: 559,
// appName: "Lotstring",
// appId: "4a2df8fc-8d35-432f-bd62-adbedfd2b22b",
// owner: "kstredwickfi",
// usersCount: 210,
// },
// {
// Id: 560,
// appName: "Vagram",
// appId: "e657c23c-4cfd-4017-a259-e25555362da1",
// owner: "spignonfj",
// usersCount: 845,
// },
// {
// Id: 561,
// appName: "Cardguard",
// appId: "fd70ae83-77a4-4226-a0f2-6fd40b770f29",
// owner: "jprettifk",
// usersCount: 320,
// },
// {
// Id: 562,
// appName: "Duobam",
// appId: "c0cc3ad0-04fd-47cc-b5d3-7b4eb427da5d",
// owner: "alackiefl",
// usersCount: 759,
// },
// {
// Id: 563,
// appName: "Temp",
// appId: "d7c8b022-515e-4369-893c-ad08c40cd047",
// owner: "tfiddimanfm",
// usersCount: 981,
// },
// {
// Id: 564,
// appName: "Treeflex",
// appId: "13bed666-6c8f-45e7-97d9-8a7f3e9da94a",
// owner: "whagyardfn",
// usersCount: 800,
// },
// {
// Id: 565,
// appName: "Hatity",
// appId: "3e0c0c2a-60d2-494a-8e1f-6566bb9edec9",
// owner: "cchargefo",
// usersCount: 939,
// },
// {
// Id: 566,
// appName: "Lotstring",
// appId: "cb5c84c2-5cc0-4b4d-9e42-5e623cae71cd",
// owner: "njarrattfp",
// usersCount: 604,
// },
// {
// Id: 567,
// appName: "Stringtough",
// appId: "702f6b25-96ee-4f7c-9d00-868f3ec69b4f",
// owner: "sgiovanninifq",
// usersCount: 54,
// },
// {
// Id: 568,
// appName: "Sub-Ex",
// appId: "9d9f88b2-1436-4f21-b6f1-5e67d5bd6440",
// owner: "cvasilyevskifr",
// usersCount: 19,
// },
// {
// Id: 569,
// appName: "Flexidy",
// appId: "84f8ea35-069f-4295-9a3e-a11371fd048a",
// owner: "gpiddletownfs",
// usersCount: 900,
// },
// {
// Id: 570,
// appName: "Tampflex",
// appId: "7fd1f0fc-19ed-4912-984d-7f599dbe32f1",
// owner: "btateft",
// usersCount: 449,
// },
// {
// Id: 571,
// appName: "Matsoft",
// appId: "910c905a-fdc0-4403-a555-c268d4f8de65",
// owner: "jmartignonfu",
// usersCount: 254,
// },
// {
// Id: 572,
// appName: "Fintone",
// appId: "54e5d6e5-aca4-4496-a5a6-b40ea454454c",
// owner: "asirmonfv",
// usersCount: 530,
// },
// {
// Id: 573,
// appName: "Treeflex",
// appId: "6dba45a0-0bbd-403c-88c7-3cd3114946f0",
// owner: "mcrewefw",
// usersCount: 218,
// },
// {
// Id: 574,
// appName: "Stim",
// appId: "6b9e903f-90f7-4c4c-b743-1c92fe58c2e8",
// owner: "msangerfx",
// usersCount: 151,
// },
// {
// Id: 575,
// appName: "Flowdesk",
// appId: "08713478-8487-4363-8305-3f92a0c02364",
// owner: "ljindrakfy",
// usersCount: 988,
// },
// {
// Id: 576,
// appName: "Tresom",
// appId: "c7c0dbbb-a40c-4c03-b72d-28502858af13",
// owner: "mmuehlefz",
// usersCount: 27,
// },
// {
// Id: 577,
// appName: "Tempsoft",
// appId: "3bfaddab-a1a5-48bb-a592-5cb516ab9789",
// owner: "mreahg0",
// usersCount: 286,
// },
// {
// Id: 578,
// appName: "Konklab",
// appId: "4bb7a7d7-bf40-417e-b861-b265c104bac8",
// owner: "fsharrierg1",
// usersCount: 341,
// },
// {
// Id: 579,
// appName: "Regrant",
// appId: "fe32d3d1-114b-4577-856b-9eb183dcb65d",
// owner: "hvautierg2",
// usersCount: 563,
// },
// {
// Id: 580,
// appName: "Lotstring",
// appId: "5dcd80f8-41a0-41db-a0f2-09fa0bd03679",
// owner: "xgiorgig3",
// usersCount: 437,
// },
// {
// Id: 581,
// appName: "Hatity",
// appId: "ac85c5df-c413-469b-a912-b70c32ca151d",
// owner: "ebohling4",
// usersCount: 892,
// },
// {
// Id: 582,
// appName: "Bitchip",
// appId: "d9046719-f423-482e-b365-76ba6a49675f",
// owner: "fhonackg5",
// usersCount: 72,
// },
// {
// Id: 583,
// appName: "Sonair",
// appId: "7386f961-9e0b-4a08-9b58-edee1c072fb0",
// owner: "acleghorng6",
// usersCount: 147,
// },
// {
// Id: 584,
// appName: "Alpha",
// appId: "de8f64b0-7275-4ce8-9f0e-a25f34f6b761",
// owner: "ltiddg7",
// usersCount: 161,
// },
// {
// Id: 585,
// appName: "Tin",
// appId: "4e67711c-788c-4286-849e-f7d4762fc36d",
// owner: "nmelliardg8",
// usersCount: 391,
// },
// {
// Id: 586,
// appName: "Stronghold",
// appId: "a01464a2-a935-4f20-84a6-fc952e604072",
// owner: "dcabralesg9",
// usersCount: 48,
// },
// {
// Id: 587,
// appName: "Keylex",
// appId: "562e9292-f469-4488-8d1a-21c04c941a31",
// owner: "gmasselinga",
// usersCount: 984,
// },
// {
// Id: 588,
// appName: "Holdlamis",
// appId: "2ee47539-8113-4651-af25-81d9b2a2f8ea",
// owner: "lragsdalegb",
// usersCount: 441,
// },
// {
// Id: 589,
// appName: "Y-Solowarm",
// appId: "f9f096dd-406d-461c-b076-3032a25dd3da",
// owner: "kmerrydewgc",
// usersCount: 993,
// },
// {
// Id: 590,
// appName: "Quo Lux",
// appId: "587948ea-a851-4c75-a46f-20ffba392ce6",
// owner: "bcousergd",
// usersCount: 72,
// },
// {
// Id: 591,
// appName: "Redhold",
// appId: "6d691627-0968-48b7-9847-2b613704b07c",
// owner: "elehucquetge",
// usersCount: 146,
// },
// {
// Id: 592,
// appName: "Tempsoft",
// appId: "47f13505-6fdd-4897-822e-b0d91478c03b",
// owner: "bjerromesgf",
// usersCount: 584,
// },
// {
// Id: 593,
// appName: "Toughjoyfax",
// appId: "2929f897-86c1-45df-99e9-0b6733de28d9",
// owner: "cmacphailgg",
// usersCount: 337,
// },
// {
// Id: 594,
// appName: "Subin",
// appId: "1dac00ae-d314-4e48-a836-e65145970fca",
// owner: "tpeterigh",
// usersCount: 581,
// },
// {
// Id: 595,
// appName: "Konklux",
// appId: "3a4fcd9c-ec15-4647-9fa4-0f946af0e216",
// owner: "cdowtrygi",
// usersCount: 751,
// },
// {
// Id: 596,
// appName: "Flexidy",
// appId: "25abbd56-a7fd-4553-8935-a335802d1b04",
// owner: "lcamamillgj",
// usersCount: 432,
// },
// {
// Id: 597,
// appName: "Lotstring",
// appId: "0f23e777-80c7-45ac-94b5-a8123de3f9e5",
// owner: "parmfieldgk",
// usersCount: 154,
// },
// {
// Id: 598,
// appName: "Bamity",
// appId: "8580195c-d723-4874-9244-9bd64d7be8f6",
// owner: "jmollindiniagl",
// usersCount: 631,
// },
// {
// Id: 599,
// appName: "Stim",
// appId: "a05053a4-e08e-46f7-b943-aa91b4616f44",
// owner: "jmcphelimygm",
// usersCount: 734,
// },
// {
// Id: 600,
// appName: "Bigtax",
// appId: "6ce921c5-c1fe-4383-b474-8c58b777a65c",
// owner: "ccoltangn",
// usersCount: 291,
// },
// {
// Id: 601,
// appName: "Bamity",
// appId: "ff2708ae-c6ec-4ca6-9b7a-cde566cbb0d4",
// owner: "rolynngo",
// usersCount: 277,
// },
// {
// Id: 602,
// appName: "Fix San",
// appId: "78719c30-799e-4a32-b293-347528956cff",
// owner: "froylegp",
// usersCount: 67,
// },
// {
// Id: 603,
// appName: "Prodder",
// appId: "1c0474c2-5846-4aca-8a98-6f84220987b7",
// owner: "atrayesgq",
// usersCount: 221,
// },
// {
// Id: 604,
// appName: "Overhold",
// appId: "a1adc784-bb4d-4b3e-a788-d356f4265b39",
// owner: "cclaveringgr",
// usersCount: 446,
// },
// {
// Id: 605,
// appName: "Cardguard",
// appId: "e766d689-6eca-4e36-916f-08d33f9bfa8a",
// owner: "rkinnettgs",
// usersCount: 17,
// },
// {
// Id: 606,
// appName: "Keylex",
// appId: "f874ac84-bd65-4f3c-865d-a483648c5a0f",
// owner: "dvernallsgt",
// usersCount: 692,
// },
// {
// Id: 607,
// appName: "Regrant",
// appId: "bd33a578-724a-4fc5-9660-580336cea47d",
// owner: "nbraysongu",
// usersCount: 296,
// },
// {
// Id: 608,
// appName: "Treeflex",
// appId: "c8770d1d-20d9-4189-921d-c4ae89ef9ec0",
// owner: "ccardenosogv",
// usersCount: 98,
// },
// {
// Id: 609,
// appName: "Latlux",
// appId: "36efc17d-a2cf-4282-93f0-680ec56f7aba",
// owner: "mgoodhallgw",
// usersCount: 586,
// },
// {
// Id: 610,
// appName: "Voltsillam",
// appId: "210e8cfd-2b75-4083-9a0e-d8ac0602f2d9",
// owner: "ghanscombegx",
// usersCount: 526,
// },
// {
// Id: 611,
// appName: "Span",
// appId: "2cac6a28-5dd6-415e-99f3-e410a80312eb",
// owner: "cgillmangy",
// usersCount: 623,
// },
// {
// Id: 612,
// appName: "Wrapsafe",
// appId: "e26e9bc0-76ae-40d1-9bf1-3e065990c8a1",
// owner: "ophelipgz",
// usersCount: 279,
// },
// {
// Id: 613,
// appName: "Opela",
// appId: "ab1cd146-48f5-4607-8e72-5026e696672c",
// owner: "pdurbannh0",
// usersCount: 308,
// },
// {
// Id: 614,
// appName: "Namfix",
// appId: "4eed69e4-878a-458c-928c-1c68d95843d4",
// owner: "omeffenh1",
// usersCount: 395,
// },
// {
// Id: 615,
// appName: "Temp",
// appId: "03a3f29e-7b9f-4faf-ba0f-c0ea65d12c88",
// owner: "abucknerh2",
// usersCount: 102,
// },
// {
// Id: 616,
// appName: "Fixflex",
// appId: "f1cfe788-889d-48f7-bf6b-b712076455b9",
// owner: "hwemyssh3",
// usersCount: 499,
// },
// {
// Id: 617,
// appName: "Greenlam",
// appId: "30830d02-d919-4599-baeb-cf22228d6031",
// owner: "rstilliardh4",
// usersCount: 874,
// },
// {
// Id: 618,
// appName: "It",
// appId: "39f799d6-ca46-4610-8c05-d4ea656db5ae",
// owner: "cblunth5",
// usersCount: 664,
// },
// {
// Id: 619,
// appName: "Bamity",
// appId: "76e6a9a2-c7a6-4023-a71e-26f7bbf08c8a",
// owner: "hchiverstoneh6",
// usersCount: 697,
// },
// {
// Id: 620,
// appName: "Lotlux",
// appId: "c224ed8e-feb1-42a4-a759-48c635cd2c70",
// owner: "eduligalh7",
// usersCount: 355,
// },
// {
// Id: 621,
// appName: "Job",
// appId: "6d20979a-6075-40be-8ee7-502411fbd5e0",
// owner: "iheapsh8",
// usersCount: 807,
// },
// {
// Id: 622,
// appName: "Hatity",
// appId: "c4589360-9d14-4b89-bd3f-49db9fbe6cc0",
// owner: "vpavlasekh9",
// usersCount: 924,
// },
// {
// Id: 623,
// appName: "Holdlamis",
// appId: "b40089ec-dcf0-4176-812a-78299c6ed3ac",
// owner: "cgreedingha",
// usersCount: 998,
// },
// {
// Id: 624,
// appName: "Stim",
// appId: "5bad7cf7-2a72-41ed-959e-51e549f89048",
// owner: "slawleehb",
// usersCount: 122,
// },
// {
// Id: 625,
// appName: "Voyatouch",
// appId: "bac2add4-635c-4490-b64c-ddb08c25707a",
// owner: "kgaleyhc",
// usersCount: 461,
// },
// {
// Id: 626,
// appName: "It",
// appId: "8e8cd254-7a82-49e8-9218-ba0e9c2221a6",
// owner: "gfunnellhd",
// usersCount: 966,
// },
// {
// Id: 627,
// appName: "Tin",
// appId: "d36db75a-2b1d-4b9e-bd5f-a0aaf3cc38fb",
// owner: "dpatridgehe",
// usersCount: 368,
// },
// {
// Id: 628,
// appName: "Home Ing",
// appId: "7db9006c-71f8-4255-94df-b54c7774c2f6",
// owner: "ddomelowhf",
// usersCount: 862,
// },
// {
// Id: 629,
// appName: "Toughjoyfax",
// appId: "75bf41be-4c89-4c43-a7cf-71b07c2558ea",
// owner: "xadolthinehg",
// usersCount: 973,
// },
// {
// Id: 630,
// appName: "Voltsillam",
// appId: "12739a0d-7d4c-45ac-ae81-dcace80bc101",
// owner: "bbienvenuhh",
// usersCount: 999,
// },
// {
// Id: 631,
// appName: "Alpha",
// appId: "73091613-3eac-4548-86a2-cec2a5451613",
// owner: "kmohammadhi",
// usersCount: 223,
// },
// {
// Id: 632,
// appName: "Tin",
// appId: "1916dd6a-e316-451a-9233-71c144afb05f",
// owner: "mmcdonnellhj",
// usersCount: 543,
// },
// {
// Id: 633,
// appName: "Zamit",
// appId: "1ba49edc-eb75-459c-a7da-8512dcef4e19",
// owner: "eharrhyhk",
// usersCount: 701,
// },
// {
// Id: 634,
// appName: "Zamit",
// appId: "1eca3332-f87d-4631-abef-b30f1ac2029f",
// owner: "calbertihl",
// usersCount: 492,
// },
// {
// Id: 635,
// appName: "Zamit",
// appId: "0e552414-66bf-4501-85b4-c2d266b904e5",
// owner: "thorthm",
// usersCount: 475,
// },
// {
// Id: 636,
// appName: "Y-find",
// appId: "15962790-b710-4440-a03a-eec27d19613f",
// owner: "wdanellhn",
// usersCount: 651,
// },
// {
// Id: 637,
// appName: "Keylex",
// appId: "1e219543-9c39-4b9d-8cd5-6ab28d158798",
// owner: "msimonyho",
// usersCount: 859,
// },
// {
// Id: 638,
// appName: "Flowdesk",
// appId: "0b678943-9a34-4cb1-ac3a-bb1f7ee113a3",
// owner: "dclaxsonhp",
// usersCount: 122,
// },
// {
// Id: 639,
// appName: "Flexidy",
// appId: "74fc6459-5818-4eda-9a6a-81a047165f35",
// owner: "agilbankshq",
// usersCount: 825,
// },
// {
// Id: 640,
// appName: "Duobam",
// appId: "0fe2af84-3b38-4703-8b9d-f55d6a86ef95",
// owner: "stomaszynskihr",
// usersCount: 393,
// },
// {
// Id: 641,
// appName: "Job",
// appId: "0e2cc9c0-08e5-49b8-bab5-2aa6b4d0a815",
// owner: "vjurkowskihs",
// usersCount: 584,
// },
// {
// Id: 642,
// appName: "Stringtough",
// appId: "c4bc084c-77e1-4bba-938e-a11be9d87bd5",
// owner: "kdufaireht",
// usersCount: 428,
// },
// {
// Id: 643,
// appName: "Otcom",
// appId: "a112beb5-8c67-46c4-b892-aee88b83e6f8",
// owner: "glynnhu",
// usersCount: 241,
// },
// {
// Id: 644,
// appName: "Job",
// appId: "eeb52a67-5d7a-4030-80cc-78d403d751fb",
// owner: "gungerechtshv",
// usersCount: 671,
// },
// {
// Id: 645,
// appName: "Fixflex",
// appId: "382a72e3-cc96-49fb-97ee-4683a2853503",
// owner: "cvolontehw",
// usersCount: 255,
// },
// {
// Id: 646,
// appName: "Voltsillam",
// appId: "8cb938d9-1589-481d-abe3-d0b936b5fa3e",
// owner: "rpeverellhx",
// usersCount: 433,
// },
// {
// Id: 647,
// appName: "Daltfresh",
// appId: "6f511b28-bce1-4f9c-aa28-7b02a1bdf23e",
// owner: "lmagennyhy",
// usersCount: 724,
// },
// {
// Id: 648,
// appName: "Subin",
// appId: "c877db3e-8769-478a-89a3-b1f0daf4cbc0",
// owner: "omussardhz",
// usersCount: 757,
// },
// {
// Id: 649,
// appName: "Wrapsafe",
// appId: "6c1d5d6c-856d-4408-9b45-2fab73ff4480",
// owner: "pcashleyi0",
// usersCount: 595,
// },
// {
// Id: 650,
// appName: "Keylex",
// appId: "2ef3aa93-0838-45e8-943b-d56a4e790682",
// owner: "pklugeri1",
// usersCount: 177,
// },
// {
// Id: 651,
// appName: "Alpha",
// appId: "4f9748fe-2367-41e2-b91c-e1e7c89603e4",
// owner: "fbrierleyi2",
// usersCount: 816,
// },
// {
// Id: 652,
// appName: "Asoka",
// appId: "fb454f41-f604-488d-a814-117a68a38c42",
// owner: "omaccriei3",
// usersCount: 217,
// },
// {
// Id: 653,
// appName: "Greenlam",
// appId: "4906f431-68cb-4a5f-8fe4-9108a603ed6d",
// owner: "escalai4",
// usersCount: 664,
// },
// {
// Id: 654,
// appName: "<NAME>",
// appId: "1973ec2f-de21-46b2-b15a-8ebff616a154",
// owner: "kmaclavertyi5",
// usersCount: 886,
// },
// {
// Id: 655,
// appName: "Holdlamis",
// appId: "a3d5b772-3c5f-46fe-97f6-a70884f4778f",
// owner: "santhiftlei6",
// usersCount: 679,
// },
// {
// Id: 656,
// appName: "Transcof",
// appId: "801ded4f-e198-47c3-9f5b-ae2c963783cd",
// owner: "atumultyi7",
// usersCount: 537,
// },
// {
// Id: 657,
// appName: "Subin",
// appId: "a4af4d08-e196-4d94-a777-172f4c22fd36",
// owner: "tbogiesi8",
// usersCount: 24,
// },
// {
// Id: 658,
// appName: "Zaam-Dox",
// appId: "7bb6ce05-4de5-4b81-8dc2-595317ddadeb",
// owner: "mparadisei9",
// usersCount: 44,
// },
// {
// Id: 659,
// appName: "Bigtax",
// appId: "27e79d49-62d0-4049-a737-f27ebe1d5da1",
// owner: "ksheeringia",
// usersCount: 46,
// },
// {
// Id: 660,
// appName: "Opela",
// appId: "29e9a8a8-2778-47b3-89a2-d455865043e4",
// owner: "bvondruskaib",
// usersCount: 376,
// },
// {
// Id: 661,
// appName: "Zontrax",
// appId: "3263947e-e509-4346-bca0-6017b3db70f1",
// owner: "amartijnic",
// usersCount: 52,
// },
// {
// Id: 662,
// appName: "Fixflex",
// appId: "da6d4257-4aea-49ff-8083-62d4be565d5a",
// owner: "bpettengellid",
// usersCount: 275,
// },
// {
// Id: 663,
// appName: "Tresom",
// appId: "181a3d12-b72f-4856-83a0-53a3739ba64f",
// owner: "nseywoodie",
// usersCount: 132,
// },
// {
// Id: 664,
// appName: "Zontrax",
// appId: "7b431004-f8c5-4a51-b333-6e6e1251e0ef",
// owner: "yosgorbyif",
// usersCount: 55,
// },
// {
// Id: 665,
// appName: "Sonsing",
// appId: "a5f7ad54-6f51-4361-aa30-ed79611779b7",
// owner: "loheaneyig",
// usersCount: 715,
// },
// {
// Id: 666,
// appName: "Matsoft",
// appId: "f37fb21a-358b-4bc0-a9a2-eb03bb8a0297",
// owner: "avigneih",
// usersCount: 330,
// },
// {
// Id: 667,
// appName: "Andalax",
// appId: "1691c39e-6bd9-48fa-8296-bed4c5417ffb",
// owner: "ndanzelmanii",
// usersCount: 781,
// },
// {
// Id: 668,
// appName: "Y-Solowarm",
// appId: "de8d2601-1cfd-43bc-8c86-3a23c997ae83",
// owner: "ijobeyij",
// usersCount: 662,
// },
// {
// Id: 669,
// appName: "Kanlam",
// appId: "74f180f9-811b-4206-b431-8c1658e8748f",
// owner: "driddioughik",
// usersCount: 899,
// },
// {
// Id: 670,
// appName: "Viva",
// appId: "f811f9d6-b054-4732-a7da-3d8f8e726d88",
// owner: "wcomazzoil",
// usersCount: 130,
// },
// {
// Id: 671,
// appName: "Zoolab",
// appId: "8be6e3e0-5e1c-435c-8bf9-03d098a5ba17",
// owner: "vsoleim",
// usersCount: 176,
// },
// {
// Id: 672,
// appName: "Solarbreeze",
// appId: "64753c7d-e14e-4e5a-a020-3c9a802cd207",
// owner: "ezanneliin",
// usersCount: 606,
// },
// {
// Id: 673,
// appName: "Zoolab",
// appId: "05e7d38f-de38-4ba7-b331-051727234252",
// owner: "joddeio",
// usersCount: 615,
// },
// {
// Id: 674,
// appName: "Cardguard",
// appId: "7e331eba-6554-4070-8e68-db41502b0efa",
// owner: "kstopherip",
// usersCount: 499,
// },
// {
// Id: 675,
// appName: "Alpha",
// appId: "698dccb1-81a0-4e40-8c40-f43fed7abb2c",
// owner: "alachaizeiq",
// usersCount: 410,
// },
// {
// Id: 676,
// appName: "Transcof",
// appId: "9f9afb32-6192-4eac-8121-972c410fd1d2",
// owner: "hgianniir",
// usersCount: 964,
// },
// {
// Id: 677,
// appName: "Bytecard",
// appId: "6c1b2325-f22d-4845-b26c-efcfbc98c29f",
// owner: "adockreyis",
// usersCount: 868,
// },
// {
// Id: 678,
// appName: "Biodex",
// appId: "cbc69a9c-c10d-484f-be3a-20eb2928df2e",
// owner: "cmcinultyit",
// usersCount: 471,
// },
// {
// Id: 679,
// appName: "Bamity",
// appId: "ece3dfd8-e852-4aeb-9a51-e766eba52c2a",
// owner: "rcatlowiu",
// usersCount: 19,
// },
// {
// Id: 680,
// appName: "Tresom",
// appId: "6805e018-794e-457f-b971-be8788ee583f",
// owner: "tgallantiv",
// usersCount: 704,
// },
// {
// Id: 681,
// appName: "Tresom",
// appId: "bd3a7b8e-b74d-46da-a2a2-de96e63c1efc",
// owner: "lschroderiw",
// usersCount: 731,
// },
// {
// Id: 682,
// appName: "Hatity",
// appId: "199c74d3-375a-4efc-86f2-ca39a0c363d1",
// owner: "eoxburghix",
// usersCount: 998,
// },
// {
// Id: 683,
// appName: "Biodex",
// appId: "93fecf7f-ee8b-44f6-93ab-e90cb891c364",
// owner: "srudeiy",
// usersCount: 222,
// },
// {
// Id: 684,
// appName: "Konklab",
// appId: "1bce5a53-a94e-479b-91aa-cc91c18279e8",
// owner: "chollingdaleiz",
// usersCount: 584,
// },
// {
// Id: 685,
// appName: "Toughjoyfax",
// appId: "c778abf9-4ddf-49f2-9749-c180efd257bc",
// owner: "ftamsettj0",
// usersCount: 299,
// },
// {
// Id: 686,
// appName: "Cookley",
// appId: "52f2e3b4-e68d-4fbd-9e52-69e67ad07e2e",
// owner: "amannj1",
// usersCount: 210,
// },
// {
// Id: 687,
// appName: "Alpha",
// appId: "71e8f6ca-9833-4e5a-9036-10b9ba415d2c",
// owner: "lscurmanj2",
// usersCount: 120,
// },
// {
// Id: 688,
// appName: "Matsoft",
// appId: "dde65607-795c-496c-84f7-1f67f6b9c208",
// owner: "tcorkellj3",
// usersCount: 475,
// },
// {
// Id: 689,
// appName: "Holdlamis",
// appId: "b9622e9f-f4a5-4ebe-8a9b-d2db0ae5f17b",
// owner: "ginmanj4",
// usersCount: 461,
// },
// {
// Id: 690,
// appName: "Otcom",
// appId: "89adff6f-6a4c-4314-af69-43d9366abe63",
// owner: "kfreschij5",
// usersCount: 24,
// },
// {
// Id: 691,
// appName: "Y-find",
// appId: "ee91fa15-e3e4-4b21-9200-f9596b967078",
// owner: "jalderwickj6",
// usersCount: 939,
// },
// {
// Id: 692,
// appName: "Gembucket",
// appId: "45f0282b-6cfb-4cd6-a56f-aa170e43d90a",
// owner: "hrunciej7",
// usersCount: 950,
// },
// {
// Id: 693,
// appName: "Konklab",
// appId: "d4b12e71-fe24-4b05-9be3-8934b71423cc",
// owner: "dwarbeysj8",
// usersCount: 963,
// },
// {
// Id: 694,
// appName: "Holdlamis",
// appId: "d21ab8b4-d1a9-4686-a939-82caac6fd789",
// owner: "sdickj9",
// usersCount: 639,
// },
// {
// Id: 695,
// appName: "Alpha",
// appId: "1679aef1-e11a-4ecd-88e6-b9c14c937faf",
// owner: "asandersonja",
// usersCount: 640,
// },
// {
// Id: 696,
// appName: "Pannier",
// appId: "79ff4b52-7a1f-46cd-8f0a-59e5773c404c",
// owner: "dscotchmerjb",
// usersCount: 737,
// },
// {
// Id: 697,
// appName: "Fix San",
// appId: "5f8f9f6f-fa98-47b8-aaa0-cca001d32aa8",
// owner: "vkareljc",
// usersCount: 587,
// },
// {
// Id: 698,
// appName: "Latlux",
// appId: "6d20017e-5824-4ce0-b1fd-0212f6e07c6d",
// owner: "jloftyjd",
// usersCount: 738,
// },
// {
// Id: 699,
// appName: "Tres-Zap",
// appId: "cb78996b-b20c-4785-8af9-1ac9c44500e6",
// owner: "aoldredje",
// usersCount: 627,
// },
// {
// Id: 700,
// appName: "Tampflex",
// appId: "7f5abc6c-7370-43b6-9e2d-ee8328613e2d",
// owner: "kosemanjf",
// usersCount: 42,
// },
// {
// Id: 701,
// appName: "Opela",
// appId: "abe73f4f-2934-4045-bc2b-50aca6720da2",
// owner: "jtoulchjg",
// usersCount: 711,
// },
// {
// Id: 702,
// appName: "Asoka",
// appId: "ec942350-20ce-44a7-8c12-a91fa09669e8",
// owner: "cmariansjh",
// usersCount: 785,
// },
// {
// Id: 703,
// appName: "Fix San",
// appId: "e6cb86f0-8250-485e-a7e2-49d0d3ee4562",
// owner: "lchettoeji",
// usersCount: 38,
// },
// {
// Id: 704,
// appName: "Alphazap",
// appId: "5f9b77e0-e86d-4ba3-bd69-4d7e51e3d77e",
// owner: "vbrotheridgejj",
// usersCount: 757,
// },
// {
// Id: 705,
// appName: "Sonair",
// appId: "06f89d38-429e-48bc-95b4-e3dd62eea355",
// owner: "wvanderweedenburgjk",
// usersCount: 365,
// },
// {
// Id: 706,
// appName: "Prodder",
// appId: "a83c3ea5-6701-4630-84d2-6b004c3a14cf",
// owner: "nheepsjl",
// usersCount: 37,
// },
// {
// Id: 707,
// appName: "Rank",
// appId: "02d94ba9-ae8a-4c83-a4a9-b3e6a9b37ba4",
// owner: "crapleyjm",
// usersCount: 896,
// },
// {
// Id: 708,
// appName: "Kanlam",
// appId: "677986fb-1685-43d9-9b52-6f5c64e08097",
// owner: "ciacapuccijn",
// usersCount: 466,
// },
// {
// Id: 709,
// appName: "Hatity",
// appId: "ede7c15a-93e5-49df-8d36-6eeeacd09e2d",
// owner: "ltappjo",
// usersCount: 272,
// },
// {
// Id: 710,
// appName: "Job",
// appId: "0ea4e95e-c931-4cd3-9dac-2dee71ab21ff",
// owner: "crobersonjp",
// usersCount: 683,
// },
// {
// Id: 711,
// appName: "Bytecard",
// appId: "8f8c03ef-4ddf-4c79-8293-731b33a2f25f",
// owner: "pdewsjq",
// usersCount: 572,
// },
// {
// Id: 712,
// appName: "Konklux",
// appId: "05e1ab64-2b1a-49df-af5e-70181acb6239",
// owner: "ccysterjr",
// usersCount: 925,
// },
// {
// Id: 713,
// appName: "Viva",
// appId: "2bdfcd75-1232-4fd6-8dce-9f397b408dc1",
// owner: "mvalekjs",
// usersCount: 80,
// },
// {
// Id: 714,
// appName: "Wrapsafe",
// appId: "6edf6777-a3e4-48b6-b13a-af90542ec57d",
// owner: "kdreesjt",
// usersCount: 893,
// },
// {
// Id: 715,
// appName: "Y-find",
// appId: "81ec7175-915e-4363-977e-b2e2c8082b4b",
// owner: "wponcetju",
// usersCount: 657,
// },
// {
// Id: 716,
// appName: "Vagram",
// appId: "64926b05-bc2c-4e65-a2bc-3bf131a77660",
// owner: "sransomjv",
// usersCount: 749,
// },
// {
// Id: 717,
// appName: "Span",
// appId: "6ef8e73c-f39f-4587-9c44-7dd7b8c2660a",
// owner: "lchongjw",
// usersCount: 69,
// },
// {
// Id: 718,
// appName: "Greenlam",
// appId: "78cb6a0c-f8ae-444c-90c7-adb800be4f91",
// owner: "jconmanjx",
// usersCount: 14,
// },
// {
// Id: 719,
// appName: "Hatity",
// appId: "b86fbbcd-9953-4c02-b997-b2c58a1e98bd",
// owner: "npottsjy",
// usersCount: 152,
// },
// {
// Id: 720,
// appName: "Ronstring",
// appId: "ad2b15b3-341d-4978-bc03-a049f2d9d029",
// owner: "smartignonjz",
// usersCount: 457,
// },
// {
// Id: 721,
// appName: "Y-find",
// appId: "6b4a1b0c-170b-4176-bb18-1356772812d1",
// owner: "bplumridgek0",
// usersCount: 288,
// },
// {
// Id: 722,
// appName: "Home Ing",
// appId: "650362f9-ba67-49e0-8ff6-096ff7a834a0",
// owner: "ekindlek1",
// usersCount: 501,
// },
// {
// Id: 723,
// appName: "Stronghold",
// appId: "241b4b6e-8002-419f-8794-85e27673e09c",
// owner: "asinkink2",
// usersCount: 177,
// },
// {
// Id: 724,
// appName: "Treeflex",
// appId: "ad174295-1ae3-4e87-9e56-edcd38267472",
// owner: "ppallantk3",
// usersCount: 994,
// },
// {
// Id: 725,
// appName: "Zathin",
// appId: "d284b6d1-b447-443b-a564-78734d2df128",
// owner: "hraithmillk4",
// usersCount: 557,
// },
// {
// Id: 726,
// appName: "Tempsoft",
// appId: "cd14d0cb-9e06-4e56-a6b9-cb5989472b42",
// owner: "cmourguek5",
// usersCount: 199,
// },
// {
// Id: 727,
// appName: "Tempsoft",
// appId: "bea66fac-e63b-4d41-9ddb-fe98de1e4dc5",
// owner: "kfillgatek6",
// usersCount: 483,
// },
// {
// Id: 728,
// appName: "Stim",
// appId: "684c7b0b-3791-47f9-8aae-c33eaa6f9c77",
// owner: "blewardk7",
// usersCount: 352,
// },
// {
// Id: 729,
// appName: "Konklab",
// appId: "9b2cd47e-d30e-4de8-a60b-4eac5c0665ed",
// owner: "mstampek8",
// usersCount: 212,
// },
// {
// Id: 730,
// appName: "Ronstring",
// appId: "290bc11c-65a4-47d7-8a50-66a4899307ba",
// owner: "owillgressk9",
// usersCount: 497,
// },
// {
// Id: 731,
// appName: "Solarbreeze",
// appId: "ed832abe-b45c-4279-933d-31cd7684292f",
// owner: "lheustaceka",
// usersCount: 582,
// },
// {
// Id: 732,
// appName: "Keylex",
// appId: "4d35d81e-d968-4fa0-8c19-7d94ef5789b9",
// owner: "tlarmettkb",
// usersCount: 292,
// },
// {
// Id: 733,
// appName: "Gembucket",
// appId: "de5c5962-5de0-4641-b22b-f49e61dc85d7",
// owner: "ptoplisskc",
// usersCount: 229,
// },
// {
// Id: 734,
// appName: "Sub-Ex",
// appId: "c8760cd4-4440-4ff4-bdcb-efda1416e1c0",
// owner: "mferierkd",
// usersCount: 238,
// },
// {
// Id: 735,
// appName: "Redhold",
// appId: "6d957915-96f4-4982-a140-2736a1ed2719",
// owner: "hboydellke",
// usersCount: 370,
// },
// {
// Id: 736,
// appName: "Aerified",
// appId: "8f3f3d94-73c8-446d-99eb-23b95c4e33ae",
// owner: "ramorinekf",
// usersCount: 314,
// },
// {
// Id: 737,
// appName: "Andalax",
// appId: "a9e5ec6a-5cb8-48b6-beef-4f1531e4e873",
// owner: "gcossumkg",
// usersCount: 861,
// },
// {
// Id: 738,
// appName: "Ronstring",
// appId: "944070e9-8611-4b00-8438-f1de036aacfb",
// owner: "chembrykh",
// usersCount: 502,
// },
// {
// Id: 739,
// appName: "Cardify",
// appId: "7c59e4e7-5298-4598-a1a9-50be73561131",
// owner: "sgirckeki",
// usersCount: 663,
// },
// {
// Id: 740,
// appName: "Flexidy",
// appId: "67ec5f4c-75bc-4e0a-844b-15b0f1da90bb",
// owner: "moharekj",
// usersCount: 527,
// },
// {
// Id: 741,
// appName: "Voyatouch",
// appId: "ef7feaa3-a991-480e-a195-e7f90bcca56b",
// owner: "bsweedkk",
// usersCount: 712,
// },
// {
// Id: 742,
// appName: "Sonair",
// appId: "ca249934-6831-426b-94c0-b25bbb0d8cc8",
// owner: "fbownaskl",
// usersCount: 753,
// },
// {
// Id: 743,
// appName: "Latlux",
// appId: "f378c77d-6a7e-43ad-8260-6340c1391153",
// owner: "dseawardkm",
// usersCount: 604,
// },
// {
// Id: 744,
// appName: "Cookley",
// appId: "a4caa680-40cc-4888-948f-aaca36e6bc2c",
// owner: "sscraftonkn",
// usersCount: 286,
// },
// {
// Id: 745,
// appName: "Regrant",
// appId: "45921e6e-192e-4ee2-a542-e3af7e330764",
// owner: "mlinneyko",
// usersCount: 350,
// },
// {
// Id: 746,
// appName: "Pannier",
// appId: "6359e4a7-68fe-450c-b2de-850b3570478d",
// owner: "knevekp",
// usersCount: 6,
// },
// {
// Id: 747,
// appName: "Tempsoft",
// appId: "5317216b-5b41-47ea-9428-ab132b7df872",
// owner: "ddobbinsonkq",
// usersCount: 615,
// },
// {
// Id: 748,
// appName: "Gembucket",
// appId: "a5183475-3ccd-4854-b9e8-932d2cd6436a",
// owner: "wdorrekr",
// usersCount: 3,
// },
// {
// Id: 749,
// appName: "Redhold",
// appId: "2564e969-77a7-44d5-87a7-9abced55bff0",
// owner: "crysdaleks",
// usersCount: 565,
// },
// {
// Id: 750,
// appName: "Flowdesk",
// appId: "c4da5f06-851f-402e-9461-700d4361d718",
// owner: "mmeaseykt",
// usersCount: 571,
// },
// {
// Id: 751,
// appName: "Opela",
// appId: "de03676d-0747-4867-9377-eb92ca74d43c",
// owner: "dmacalroyku",
// usersCount: 341,
// },
// {
// Id: 752,
// appName: "Voltsillam",
// appId: "079f70fc-7f00-4203-b2f9-92695d641f4f",
// owner: "jblaydonkv",
// usersCount: 755,
// },
// {
// Id: 753,
// appName: "Bamity",
// appId: "506cf06f-962e-4841-8118-6606f928976e",
// owner: "mswalwelkw",
// usersCount: 984,
// },
// {
// Id: 754,
// appName: "Span",
// appId: "80e13180-b0d9-4e9a-a3a7-f7ae89494af7",
// owner: "nzuponekx",
// usersCount: 358,
// },
// {
// Id: 755,
// appName: "Temp",
// appId: "ceac034b-e852-4eb4-9c9c-74c10ca9130b",
// owner: "challstoneky",
// usersCount: 612,
// },
// {
// Id: 756,
// appName: "Andalax",
// appId: "eff445c7-fdee-4efd-948d-3b1aa1adec18",
// owner: "gsawfordkz",
// usersCount: 916,
// },
// {
// Id: 757,
// appName: "Daltfresh",
// appId: "226f96bf-6e6e-413f-b7ab-0a1709dfba62",
// owner: "ncarvelll0",
// usersCount: 10,
// },
// {
// Id: 758,
// appName: "Rank",
// appId: "60f28755-fec0-4295-ab70-df8da4c3ec68",
// owner: "mcrockfordl1",
// usersCount: 642,
// },
// {
// Id: 759,
// appName: "Sonsing",
// appId: "7085283d-7a5e-427c-9697-cecbcf6ae7fe",
// owner: "rhenriquel2",
// usersCount: 719,
// },
// {
// Id: 760,
// appName: "Fintone",
// appId: "071c6b52-a26f-4246-ae04-35b1c130cf36",
// owner: "cfaasl3",
// usersCount: 337,
// },
// {
// Id: 761,
// appName: "Voyatouch",
// appId: "0f7d8248-96c6-443f-8c09-a04e257da331",
// owner: "jrayltonl4",
// usersCount: 327,
// },
// {
// Id: 762,
// appName: "Solarbreeze",
// appId: "04a95c7a-a22c-4b1a-9762-db76c2d971c8",
// owner: "cbartholatl5",
// usersCount: 4,
// },
// {
// Id: 763,
// appName: "Alpha",
// appId: "0551cbe0-4a9c-451c-b23f-69631dcda4bb",
// owner: "thugol6",
// usersCount: 569,
// },
// {
// Id: 764,
// appName: "Fintone",
// appId: "d96431a4-61c5-47a1-92f0-0d4eab907589",
// owner: "tbarkel7",
// usersCount: 764,
// },
// {
// Id: 765,
// appName: "<NAME>",
// appId: "eee66f43-4ccf-4c3e-9bd1-f13de74eca0b",
// owner: "bjanickil8",
// usersCount: 661,
// },
// {
// Id: 766,
// appName: "Alphazap",
// appId: "7bf0dccf-8b97-4eaf-b5d4-95fbaa2aee21",
// owner: "dmacanel9",
// usersCount: 449,
// },
// {
// Id: 767,
// appName: "Flowdesk",
// appId: "08e8b3ba-b9e0-4ee2-9916-f29821f08ea7",
// owner: "apersentla",
// usersCount: 766,
// },
// {
// Id: 768,
// appName: "Zaam-Dox",
// appId: "8621b439-80a4-4cce-bb3a-c75b8fe00fdd",
// owner: "tpenninglb",
// usersCount: 984,
// },
// {
// Id: 769,
// appName: "Tresom",
// appId: "60d6aa63-5384-4f8a-85b5-20a7c7dc46ad",
// owner: "cdaethlc",
// usersCount: 796,
// },
// {
// Id: 770,
// appName: "Veribet",
// appId: "ada43c37-7169-452b-8749-1e804b0391eb",
// owner: "bcarsld",
// usersCount: 440,
// },
// {
// Id: 771,
// appName: "Cardify",
// appId: "603b4f37-bc8c-4b50-b387-2c2278b415ef",
// owner: "gpavkovicle",
// usersCount: 170,
// },
// {
// Id: 772,
// appName: "Tampflex",
// appId: "c2e67073-f660-4d9a-8fc2-0f12af48eecd",
// owner: "fbourgourlf",
// usersCount: 655,
// },
// {
// Id: 773,
// appName: "Wrapsafe",
// appId: "015d3e2d-f50c-47df-b48f-2df93584192b",
// owner: "mcorteislg",
// usersCount: 678,
// },
// {
// Id: 774,
// appName: "Latlux",
// appId: "ed654221-8a6e-41c7-a006-fb84184078b9",
// owner: "mfargelh",
// usersCount: 834,
// },
// {
// Id: 775,
// appName: "Alpha",
// appId: "01cc833a-a3c9-4e3d-96db-9011bb2a46f6",
// owner: "erishworthli",
// usersCount: 539,
// },
// {
// Id: 776,
// appName: "Sonair",
// appId: "141b275e-d321-4b23-bd36-251fee1ffc2a",
// owner: "lspightlj",
// usersCount: 995,
// },
// {
// Id: 777,
// appName: "Overhold",
// appId: "15c26581-c7dc-4606-ac41-30651cf52147",
// owner: "nhuguenetlk",
// usersCount: 477,
// },
// {
// Id: 778,
// appName: "Opela",
// appId: "365ce5d5-47ef-4c1b-98b4-d551189ba87b",
// owner: "cavramowll",
// usersCount: 492,
// },
// {
// Id: 779,
// appName: "Temp",
// appId: "e6dd9d1c-0b10-4acf-8e1f-350b83f3a102",
// owner: "wconradlm",
// usersCount: 659,
// },
// {
// Id: 780,
// appName: "Tempsoft",
// appId: "2301cc19-99df-4c71-a7be-30d7a769d392",
// owner: "roleshuninln",
// usersCount: 556,
// },
// {
// Id: 781,
// appName: "Ronstring",
// appId: "a090f391-56ff-4a79-bc96-e38d17f30648",
// owner: "msegoelo",
// usersCount: 23,
// },
// {
// Id: 782,
// appName: "Duobam",
// appId: "b054cf4a-0509-4ded-b159-d5016d4ba126",
// owner: "bswettenhamlp",
// usersCount: 114,
// },
// {
// Id: 783,
// appName: "Quo Lux",
// appId: "781c2755-d71f-426e-b65c-5b50ff83fbd2",
// owner: "clakerlq",
// usersCount: 956,
// },
// {
// Id: 784,
// appName: "Viva",
// appId: "d6997f8f-84e7-42b0-8dab-e3fad9e11961",
// owner: "kbrownlealr",
// usersCount: 714,
// },
// {
// Id: 785,
// appName: "Pannier",
// appId: "9cd3f025-71f5-4734-bb72-b2295c0606e6",
// owner: "bbrownsillls",
// usersCount: 468,
// },
// {
// Id: 786,
// appName: "Namfix",
// appId: "d63bcbb0-11f6-4565-b4a1-b4ec80360243",
// owner: "lblenkhornlt",
// usersCount: 841,
// },
// {
// Id: 787,
// appName: "Latlux",
// appId: "c53d4c25-a299-46c9-87d2-ff3c3b817974",
// owner: "dgauntleylu",
// usersCount: 164,
// },
// {
// Id: 788,
// appName: "Trippledex",
// appId: "c15383bb-f30a-4004-a0ee-8948aae4efc4",
// owner: "cpiattilv",
// usersCount: 480,
// },
// {
// Id: 789,
// appName: "Ronstring",
// appId: "3a73c833-f045-4395-8d29-f460a57f5b35",
// owner: "cexeterlw",
// usersCount: 658,
// },
// {
// Id: 790,
// appName: "Sonsing",
// appId: "4a1d148e-47e3-4637-ad93-fe248031ec9c",
// owner: "lpeacockelx",
// usersCount: 839,
// },
// {
// Id: 791,
// appName: "Voyatouch",
// appId: "5514c406-21fb-4a18-ac11-ee8c0f1f686d",
// owner: "acardenasly",
// usersCount: 723,
// },
// {
// Id: 792,
// appName: "Tin",
// appId: "855d4356-9a07-46b0-89f6-cbfa6a6127c1",
// owner: "jgathercolelz",
// usersCount: 694,
// },
// {
// Id: 793,
// appName: "Tempsoft",
// appId: "b422df76-82e5-4078-b774-978496e764cc",
// owner: "atolefreem0",
// usersCount: 742,
// },
// {
// Id: 794,
// appName: "Sonair",
// appId: "65c64e30-bc85-4dca-8710-66dcce48f8ad",
// owner: "ghughesm1",
// usersCount: 182,
// },
// {
// Id: 795,
// appName: "Toughjoyfax",
// appId: "788d2621-4c28-4db9-9f9e-3a7b0c3b7222",
// owner: "slinklaterm2",
// usersCount: 221,
// },
// {
// Id: 796,
// appName: "Quo Lux",
// appId: "7a8793e8-d8a7-4e39-ac18-244f5c91e6c7",
// owner: "gyongm3",
// usersCount: 297,
// },
// {
// Id: 797,
// appName: "Lotlux",
// appId: "a22a2abf-8b25-422c-a446-fffef0c6a978",
// owner: "iosipovm4",
// usersCount: 26,
// },
// {
// Id: 798,
// appName: "Viva",
// appId: "31e89593-bb1f-4e6e-af11-7f5451c369b8",
// owner: "hbarbrookm5",
// usersCount: 954,
// },
// {
// Id: 799,
// appName: "Y-find",
// appId: "4a665ee8-1dd4-47ba-abcc-71fee590ce7f",
// owner: "jbattesonm6",
// usersCount: 688,
// },
// {
// Id: 800,
// appName: "It",
// appId: "41cce757-a72b-4b35-a465-dccbe4038fb3",
// owner: "toldroydem7",
// usersCount: 926,
// },
// {
// Id: 801,
// appName: "Toughjoyfax",
// appId: "69de0418-8a07-4297-93cb-6da0b31a24f6",
// owner: "jisherwoodm8",
// usersCount: 258,
// },
// {
// Id: 802,
// appName: "Rank",
// appId: "4f890d8d-174e-4d34-ab2b-78a523bc384b",
// owner: "scuffem9",
// usersCount: 900,
// },
// {
// Id: 803,
// appName: "Tresom",
// appId: "41f6d4cd-747b-499b-80bd-879efabb7d0d",
// owner: "abraganzama",
// usersCount: 199,
// },
// {
// Id: 804,
// appName: "Solarbreeze",
// appId: "6bf71065-5678-48fc-b04d-db843676b059",
// owner: "eluntmb",
// usersCount: 215,
// },
// {
// Id: 805,
// appName: "Tres-Zap",
// appId: "f70f8eba-882e-4c68-b700-193989c3361a",
// owner: "bcudmoremc",
// usersCount: 407,
// },
// {
// Id: 806,
// appName: "Keylex",
// appId: "7d55ce11-0471-4468-9fb0-8d94a3e1e6a8",
// owner: "whonackmd",
// usersCount: 171,
// },
// {
// Id: 807,
// appName: "Vagram",
// appId: "afa0f81c-27c2-448d-b7cd-0944ab3cf9b2",
// owner: "aschreime",
// usersCount: 700,
// },
// {
// Id: 808,
// appName: "Veribet",
// appId: "bad9f28a-da73-4085-8715-189bdceae31b",
// owner: "rbardaymf",
// usersCount: 8,
// },
// {
// Id: 809,
// appName: "Holdlamis",
// appId: "bfdddadc-1c3f-4c11-801c-9857c47f72c3",
// owner: "sarthanmg",
// usersCount: 613,
// },
// {
// Id: 810,
// appName: "Sonsing",
// appId: "2e8c9b9d-2d37-4589-907d-3f34e1ea5309",
// owner: "jcrowsonmh",
// usersCount: 510,
// },
// {
// Id: 811,
// appName: "Kanlam",
// appId: "95230c39-3141-4662-80c7-bc50b4e3cc03",
// owner: "scupittmi",
// usersCount: 105,
// },
// {
// Id: 812,
// appName: "Tempsoft",
// appId: "ce207b66-5982-444d-8480-1e8e72225455",
// owner: "cramsaymj",
// usersCount: 130,
// },
// {
// Id: 813,
// appName: "Sonsing",
// appId: "4d926d08-8d6e-4f4a-9191-e347a24d69ae",
// owner: "lhartillmk",
// usersCount: 699,
// },
// {
// Id: 814,
// appName: "Fixflex",
// appId: "2ea0818c-94af-49a7-bb57-da40e09c264c",
// owner: "hbeckenhamml",
// usersCount: 687,
// },
// {
// Id: 815,
// appName: "Prodder",
// appId: "9573369b-40a3-4ef0-a64c-00f4633b5efd",
// owner: "afetherstonemm",
// usersCount: 170,
// },
// {
// Id: 816,
// appName: "Biodex",
// appId: "3a00897c-7b7f-4349-8d32-09fe1d8af429",
// owner: "aatkinmn",
// usersCount: 713,
// },
// {
// Id: 817,
// appName: "Fixflex",
// appId: "b8ee7ea1-99bd-434e-870c-b3e7d3f36605",
// owner: "loakemo",
// usersCount: 165,
// },
// {
// Id: 818,
// appName: "Bitchip",
// appId: "8cf8eb09-fc62-4e67-bfb3-64dd15c98ed9",
// owner: "dlampittmp",
// usersCount: 225,
// },
// {
// Id: 819,
// appName: "Cardify",
// appId: "7245e26b-2c2e-40b9-ba23-25320390e897",
// owner: "lcahalanmq",
// usersCount: 802,
// },
// {
// Id: 820,
// appName: "Domainer",
// appId: "2e2b74e9-5663-406d-b1d3-0ba786336ef3",
// owner: "htopleymr",
// usersCount: 112,
// },
// {
// Id: 821,
// appName: "Hatity",
// appId: "e6362a67-8da6-4e61-a020-0ec45d770de1",
// owner: "njirousekms",
// usersCount: 421,
// },
// {
// Id: 822,
// appName: "Holdlamis",
// appId: "a7215c5c-73ff-4c93-b52d-863220286689",
// owner: "troufmt",
// usersCount: 684,
// },
// {
// Id: 823,
// appName: "Tresom",
// appId: "e8dd813a-c905-45ab-b099-0b5c2accc492",
// owner: "elammengamu",
// usersCount: 93,
// },
// {
// Id: 824,
// appName: "<NAME>",
// appId: "ee151268-0450-40b3-a6ef-cb7d4f90ddb8",
// owner: "hmowbraymv",
// usersCount: 955,
// },
// {
// Id: 825,
// appName: "Bamity",
// appId: "6d211cf7-adf9-455d-953b-172db006a452",
// owner: "iantonikmw",
// usersCount: 598,
// },
// {
// Id: 826,
// appName: "Voyatouch",
// appId: "b22ea445-3415-4400-afb3-0a4637a5ecf3",
// owner: "cllorensmx",
// usersCount: 639,
// },
// {
// Id: 827,
// appName: "Fintone",
// appId: "c2af55fb-dee3-4cf5-bedc-2c6e56587aca",
// owner: "rbernettemy",
// usersCount: 198,
// },
// {
// Id: 828,
// appName: "Tin",
// appId: "f8a4c778-98dd-4733-9f1b-a0c3817daba0",
// owner: "mdanielemz",
// usersCount: 689,
// },
// {
// Id: 829,
// appName: "Tresom",
// appId: "7f53c9f3-0943-4c73-b631-e5451e8c39dd",
// owner: "bfoxenn0",
// usersCount: 14,
// },
// {
// Id: 830,
// appName: "Overhold",
// appId: "250d305c-a4fa-4d2d-8db2-2afc378ccebc",
// owner: "fvanvelden1",
// usersCount: 113,
// },
// {
// Id: 831,
// appName: "Zamit",
// appId: "72657249-2da4-4e35-b499-5722303e42a8",
// owner: "epratorn2",
// usersCount: 778,
// },
// {
// Id: 832,
// appName: "Transcof",
// appId: "863384ac-1561-4582-b6cf-6c9e79a32d4e",
// owner: "gkildayn3",
// usersCount: 48,
// },
// {
// Id: 833,
// appName: "Quo Lux",
// appId: "476eec10-46cd-4210-8901-0529235f35ac",
// owner: "btolfreyn4",
// usersCount: 802,
// },
// {
// Id: 834,
// appName: "Zaam-Dox",
// appId: "509e917e-48f3-4dd4-b377-47d3d48e7a1d",
// owner: "fwaterfalln5",
// usersCount: 653,
// },
// {
// Id: 835,
// appName: "Konklux",
// appId: "11c0962e-f990-46ae-bf37-f99a2f78e849",
// owner: "ulubbockn6",
// usersCount: 783,
// },
// {
// Id: 836,
// appName: "Bamity",
// appId: "dc5e6e30-4729-48e8-8f03-e36eaf57a5f2",
// owner: "lmustilln7",
// usersCount: 537,
// },
// {
// Id: 837,
// appName: "Domainer",
// appId: "b19bc517-13e7-48d0-8e4a-43cc1419fc81",
// owner: "twaddingtonn8",
// usersCount: 983,
// },
// {
// Id: 838,
// appName: "Prodder",
// appId: "b491fa83-1fee-4b92-b0d3-5b6a15be5a81",
// owner: "bmeertn9",
// usersCount: 129,
// },
// {
// Id: 839,
// appName: "Greenlam",
// appId: "7c77864b-6ebb-4f45-b7fc-c1e5a6634256",
// owner: "lewbanksna",
// usersCount: 139,
// },
// {
// Id: 840,
// appName: "Home Ing",
// appId: "20b0b7ba-7f92-4cc3-a691-fa2c7658597e",
// owner: "lisleynb",
// usersCount: 28,
// },
// {
// Id: 841,
// appName: "Zamit",
// appId: "7d3909cf-81e5-4468-b24e-f5d0ce69a814",
// owner: "bgreevesnc",
// usersCount: 38,
// },
// {
// Id: 842,
// appName: "Stringtough",
// appId: "62b25a7f-ad44-40d6-835a-65cb94bc1431",
// owner: "aferynd",
// usersCount: 161,
// },
// {
// Id: 843,
// appName: "Sonsing",
// appId: "26903d04-65e5-4875-ae7b-2bd6db791f86",
// owner: "cgasgarthne",
// usersCount: 286,
// },
// {
// Id: 844,
// appName: "Domainer",
// appId: "7f5ea887-06f7-4633-bf11-aa47afc41d71",
// owner: "smedcraftnf",
// usersCount: 197,
// },
// {
// Id: 845,
// appName: "Tempsoft",
// appId: "096e8f7d-1010-4e9b-8021-adbd1de0751e",
// owner: "sbatesonng",
// usersCount: 80,
// },
// {
// Id: 846,
// appName: "Andalax",
// appId: "e316ab44-b3a4-4fc6-b25c-e17ad75d43de",
// owner: "adanbynh",
// usersCount: 176,
// },
// {
// Id: 847,
// appName: "Namfix",
// appId: "1a819ac9-98c5-41a2-bc95-32d6b5ea3ecc",
// owner: "rrewbottomni",
// usersCount: 895,
// },
// {
// Id: 848,
// appName: "Cardguard",
// appId: "e588f08a-2007-42b1-ba57-2580740940f3",
// owner: "jjouannotnj",
// usersCount: 667,
// },
// {
// Id: 849,
// appName: "Zoolab",
// appId: "8bd5424b-3edb-449d-8d49-a0e23ab7eadd",
// owner: "fpfeiffernk",
// usersCount: 899,
// },
// {
// Id: 850,
// appName: "Zamit",
// appId: "52ee3b6d-06c7-4d7d-83b6-3e19fd245895",
// owner: "rdwinenl",
// usersCount: 49,
// },
// {
// Id: 851,
// appName: "Stim",
// appId: "41b17127-98b2-45dd-b812-da203123198f",
// owner: "mstrugnellnm",
// usersCount: 726,
// },
// {
// Id: 852,
// appName: "Cardify",
// appId: "ff4eeeec-fc18-48ea-9f31-728c7786c053",
// owner: "cconneaunn",
// usersCount: 818,
// },
// {
// Id: 853,
// appName: "Hatity",
// appId: "dd072429-b0b6-4b95-bf6c-6f9c8ec20039",
// owner: "thuittno",
// usersCount: 707,
// },
// {
// Id: 854,
// appName: "Trippledex",
// appId: "d2150108-acff-4aa6-88e7-39d1a9239ef5",
// owner: "bbeamishnp",
// usersCount: 602,
// },
// {
// Id: 855,
// appName: "Holdlamis",
// appId: "5d38b851-b259-4e9b-a868-165a58dbc2cb",
// owner: "dpontnq",
// usersCount: 5,
// },
// {
// Id: 856,
// appName: "Otcom",
// appId: "e44460cd-b7e3-4d7f-a6c6-844d3308fbca",
// owner: "wlownenr",
// usersCount: 685,
// },
// {
// Id: 857,
// appName: "Latlux",
// appId: "bfd34e22-2df2-4a55-a93b-97dd13025abd",
// owner: "mpizerns",
// usersCount: 292,
// },
// {
// Id: 858,
// appName: "Sonsing",
// appId: "25ab6e85-e0d5-43b0-8dfe-6f9d0065a3ef",
// owner: "urawlinsonnt",
// usersCount: 860,
// },
// {
// Id: 859,
// appName: "Bitwolf",
// appId: "54d36904-bd22-468e-a4f3-ce8433211aa2",
// owner: "ekrysteknu",
// usersCount: 775,
// },
// {
// Id: 860,
// appName: "Flowdesk",
// appId: "779672ca-620f-4238-b97d-05ef75183617",
// owner: "kbonellenv",
// usersCount: 760,
// },
// {
// Id: 861,
// appName: "Zamit",
// appId: "60222068-651b-43f0-878b-2c520d1bbc7d",
// owner: "dfulksnw",
// usersCount: 381,
// },
// {
// Id: 862,
// appName: "Asoka",
// appId: "0d2cb649-1e26-4314-bed9-324f4416ab08",
// owner: "rhotsonnx",
// usersCount: 528,
// },
// {
// Id: 863,
// appName: "It",
// appId: "e505b7ad-0488-4285-8c25-c82f56ec1cd7",
// owner: "blangeny",
// usersCount: 558,
// },
// {
// Id: 864,
// appName: "Bitwolf",
// appId: "403abf37-db0a-44ba-8167-c46d0f5bc744",
// owner: "dloadernz",
// usersCount: 324,
// },
// {
// Id: 865,
// appName: "Job",
// appId: "25226112-8ecd-4a2d-8615-53da6308bee8",
// owner: "saspdeno0",
// usersCount: 117,
// },
// {
// Id: 866,
// appName: "Trippledex",
// appId: "f67ee205-b667-4173-b085-4316d25acaf5",
// owner: "pskittleso1",
// usersCount: 844,
// },
// {
// Id: 867,
// appName: "Job",
// appId: "2a60c783-48f6-4d19-bf9c-deb96d4bb81a",
// owner: "sjarrelo2",
// usersCount: 225,
// },
// {
// Id: 868,
// appName: "Ventosanzap",
// appId: "12c1d179-e5e3-4c47-bdf4-ba6fcaf7512c",
// owner: "hglazyero3",
// usersCount: 519,
// },
// {
// Id: 869,
// appName: "Gembucket",
// appId: "bf0d3302-69a2-49b8-8d6d-a1ca5e54c064",
// owner: "vfantino4",
// usersCount: 131,
// },
// {
// Id: 870,
// appName: "Zontrax",
// appId: "98b5152b-b60f-4a70-b77e-cc12a18a5c21",
// owner: "msticklando5",
// usersCount: 19,
// },
// {
// Id: 871,
// appName: "Stim",
// appId: "e146df61-493f-4ade-91c7-762f9ac57705",
// owner: "cdiclaudioo6",
// usersCount: 86,
// },
// {
// Id: 872,
// appName: "Duobam",
// appId: "5f293be5-4709-403e-83c8-2d2c7078bd28",
// owner: "cruddifortho7",
// usersCount: 907,
// },
// {
// Id: 873,
// appName: "Kanlam",
// appId: "1b69ea82-6740-4dd3-8491-d842d529c519",
// owner: "atolworthieo8",
// usersCount: 227,
// },
// {
// Id: 874,
// appName: "Transcof",
// appId: "b4726a3a-534f-4266-b969-a7053cc45e5e",
// owner: "lhopkynsono9",
// usersCount: 697,
// },
// {
// Id: 875,
// appName: "Cardify",
// appId: "7afbb850-4e6c-4621-a24c-ddbf90dda658",
// owner: "edelacosteoa",
// usersCount: 679,
// },
// {
// Id: 876,
// appName: "Subin",
// appId: "cc67b15d-a517-46f0-a9b0-467266242f6f",
// owner: "gbuckelob",
// usersCount: 155,
// },
// {
// Id: 877,
// appName: "Y-Solowarm",
// appId: "c30afc45-402a-4613-9395-2e62228aea32",
// owner: "bstreateroc",
// usersCount: 896,
// },
// {
// Id: 878,
// appName: "Flowdesk",
// appId: "3105ba66-97a2-46a7-b537-b39a124e0e93",
// owner: "btruettod",
// usersCount: 699,
// },
// {
// Id: 879,
// appName: "Aerified",
// appId: "188b880b-de03-4106-bb44-79938a160d71",
// owner: "bladelloe",
// usersCount: 491,
// },
// {
// Id: 880,
// appName: "Kanlam",
// appId: "7fd1c4af-2b2e-4713-8aa0-74af20ec85e3",
// owner: "gshaylorof",
// usersCount: 355,
// },
// {
// Id: 881,
// appName: "Redhold",
// appId: "86325ac3-d4c0-498e-8d92-a765b9f40beb",
// owner: "akittoog",
// usersCount: 412,
// },
// {
// Id: 882,
// appName: "Cardguard",
// appId: "49440322-4c76-4472-8df4-15b7f0d37e9e",
// owner: "pivanisovoh",
// usersCount: 180,
// },
// {
// Id: 883,
// appName: "Solarbreeze",
// appId: "45f369d2-39d2-4a2d-b215-f19d83157796",
// owner: "swedderburnoi",
// usersCount: 745,
// },
// {
// Id: 884,
// appName: "Matsoft",
// appId: "74fd3e78-bf8c-462e-b613-db76b9a63439",
// owner: "amcphillipsoj",
// usersCount: 758,
// },
// {
// Id: 885,
// appName: "Trippledex",
// appId: "c95baa48-624d-439a-af83-b38cce5f7de3",
// owner: "vfarrarok",
// usersCount: 548,
// },
// {
// Id: 886,
// appName: "Bytecard",
// appId: "75b715fc-38af-4350-9b3d-c455edd4ad7b",
// owner: "epinnockeol",
// usersCount: 137,
// },
// {
// Id: 887,
// appName: "Tres-Zap",
// appId: "f911212b-b5d6-44f1-85e9-aeb370d03ffa",
// owner: "tmarnaneom",
// usersCount: 992,
// },
// {
// Id: 888,
// appName: "Tin",
// appId: "faa949be-070e-4e94-be92-70f654c4294b",
// owner: "orutlandon",
// usersCount: 63,
// },
// {
// Id: 889,
// appName: "Matsoft",
// appId: "f3b53cb1-0938-4b2a-b912-6eb7404616fd",
// owner: "stortoo",
// usersCount: 649,
// },
// {
// Id: 890,
// appName: "Konklab",
// appId: "51912135-e897-448b-b929-820c6daf7b8d",
// owner: "pkainzop",
// usersCount: 504,
// },
// {
// Id: 891,
// appName: "Kanlam",
// appId: "3c91ced0-c021-4f25-b0a8-95ecfbdeb5ab",
// owner: "cindruchoq",
// usersCount: 395,
// },
// {
// Id: 892,
// appName: "Span",
// appId: "fa2b92ef-6cfd-4dce-aa17-ef444938a4da",
// owner: "acatlinor",
// usersCount: 336,
// },
// {
// Id: 893,
// appName: "Cardguard",
// appId: "66db9004-b1b6-41f2-87f3-3e1e3e3109c4",
// owner: "avossingos",
// usersCount: 58,
// },
// {
// Id: 894,
// appName: "Bytecard",
// appId: "dc1c8b3c-77a0-4c9c-9edd-595d325c4171",
// owner: "aplaitot",
// usersCount: 381,
// },
// {
// Id: 895,
// appName: "Bitwolf",
// appId: "72f6751c-803d-4aef-aa8a-89286c8b3dec",
// owner: "dstraingeou",
// usersCount: 640,
// },
// {
// Id: 896,
// appName: "Holdlamis",
// appId: "89fc55b7-360b-4909-b89a-e534c99a0623",
// owner: "cbolusov",
// usersCount: 451,
// },
// {
// Id: 897,
// appName: "Matsoft",
// appId: "02e0cdce-ef3d-4c8f-96a1-3cc41d09c1bd",
// owner: "tskeletonow",
// usersCount: 180,
// },
// {
// Id: 898,
// appName: "Trippledex",
// appId: "08ed7610-ba7c-4521-b7a6-f56cdcf36481",
// owner: "rspawforthox",
// usersCount: 262,
// },
// {
// Id: 899,
// appName: "Zathin",
// appId: "039c8252-b0c9-41e3-a78e-7515b11cfe0e",
// owner: "rmillisoy",
// usersCount: 287,
// },
// {
// Id: 900,
// appName: "Asoka",
// appId: "0ea63af1-14aa-463b-8070-7f8fddc9e922",
// owner: "lgadesbyoz",
// usersCount: 759,
// },
// {
// Id: 901,
// appName: "Job",
// appId: "32639899-b095-4654-80be-77705c6a2bfc",
// owner: "dmcclellandp0",
// usersCount: 22,
// },
// {
// Id: 902,
// appName: "Tin",
// appId: "8ce0d027-8cd0-4658-8866-140db081aed3",
// owner: "jcardingp1",
// usersCount: 732,
// },
// {
// Id: 903,
// appName: "Y-Solowarm",
// appId: "41877d75-d6a6-4f59-a54e-8a3a3c613873",
// owner: "hvaggersp2",
// usersCount: 915,
// },
// {
// Id: 904,
// appName: "Viva",
// appId: "c74b2b7c-b8c6-4b27-a820-b7df13eb3949",
// owner: "hlavallp3",
// usersCount: 375,
// },
// {
// Id: 905,
// appName: "Wrapsafe",
// appId: "352c04b7-6dde-4adc-8061-90627eb82304",
// owner: "sgonninp4",
// usersCount: 731,
// },
// {
// Id: 906,
// appName: "Matsoft",
// appId: "3787b71d-7667-434e-b6b5-844103506da8",
// owner: "lcreaghp5",
// usersCount: 822,
// },
// {
// Id: 907,
// appName: "Subin",
// appId: "af4351dc-8e6e-4405-9f27-5b6f7e1c6a10",
// owner: "mflahivep6",
// usersCount: 686,
// },
// {
// Id: 908,
// appName: "Bamity",
// appId: "344847c3-0801-4b7f-a965-b4f01e17d2c0",
// owner: "pauklandp7",
// usersCount: 489,
// },
// {
// Id: 909,
// appName: "Cardguard",
// appId: "90ff7c22-f439-40c1-8766-d34701690c48",
// owner: "mkennewayp8",
// usersCount: 118,
// },
// {
// Id: 910,
// appName: "Trippledex",
// appId: "d5a1ee08-4239-4dfa-a6a6-1699dd4a5a18",
// owner: "lcoltmanp9",
// usersCount: 373,
// },
// {
// Id: 911,
// appName: "Redhold",
// appId: "e4e26760-30c1-4e5d-a29a-c5f3a7660417",
// owner: "wmiliuspa",
// usersCount: 643,
// },
// {
// Id: 912,
// appName: "Job",
// appId: "2b69fe9e-1a83-4086-9a5f-701fbad0ba51",
// owner: "adurbinpb",
// usersCount: 276,
// },
// {
// Id: 913,
// appName: "Wrapsafe",
// appId: "b47eab61-fbf0-48c6-b5dd-b9d866bd4c0c",
// owner: "collanderpc",
// usersCount: 468,
// },
// {
// Id: 914,
// appName: "Toughjoyfax",
// appId: "d3906eaa-579a-4481-9a54-3d15998bc3eb",
// owner: "gessamepd",
// usersCount: 851,
// },
// {
// Id: 915,
// appName: "Veribet",
// appId: "7e54e462-b9e2-4ca5-9677-7414b033e7d2",
// owner: "sdenerpe",
// usersCount: 278,
// },
// {
// Id: 916,
// appName: "Stronghold",
// appId: "b5b6c779-1b11-48ad-a031-e9b71eae9887",
// owner: "bagasspf",
// usersCount: 145,
// },
// {
// Id: 917,
// appName: "Bitwolf",
// appId: "7838f1d3-8ea6-472d-9a98-1c5c0f75d149",
// owner: "sjakobssonpg",
// usersCount: 132,
// },
// {
// Id: 918,
// appName: "Tampflex",
// appId: "f35f56f2-b191-4159-90de-5e7c7246472d",
// owner: "bwestgarthph",
// usersCount: 663,
// },
// {
// Id: 919,
// appName: "Ventosanzap",
// appId: "bb7e5a63-284a-47ff-b9fa-57f9c0149226",
// owner: "lrubelpi",
// usersCount: 868,
// },
// {
// Id: 920,
// appName: "Alphazap",
// appId: "183faba8-9ae9-4f35-b625-83fae2d27fcf",
// owner: "rkilnerpj",
// usersCount: 513,
// },
// {
// Id: 921,
// appName: "Alphazap",
// appId: "b1e09f54-813a-4b9e-b1af-ea4c02e74a5f",
// owner: "hcasettipk",
// usersCount: 413,
// },
// {
// Id: 922,
// appName: "Pannier",
// appId: "fde8d143-967e-4ab9-9eb3-f2f5d89c677e",
// owner: "abompaspl",
// usersCount: 875,
// },
// {
// Id: 923,
// appName: "Span",
// appId: "95958d0d-62c6-4094-b872-ca7772d92391",
// owner: "gredgravepm",
// usersCount: 478,
// },
// {
// Id: 924,
// appName: "Ventosanzap",
// appId: "80d0dc1b-2d9c-4de7-8d13-9c7c8eb9bbbb",
// owner: "cgaskellpn",
// usersCount: 757,
// },
// {
// Id: 925,
// appName: "Konklab",
// appId: "7c117043-026e-4265-a478-9e71dcb80a54",
// owner: "dyeamanpo",
// usersCount: 698,
// },
// {
// Id: 926,
// appName: "Tempsoft",
// appId: "678d1b5b-97b5-4e77-be47-577b9158e567",
// owner: "tsmurfitpp",
// usersCount: 409,
// },
// {
// Id: 927,
// appName: "Span",
// appId: "10c06efd-57f4-45a5-966a-8c26bb34e651",
// owner: "achaytorpq",
// usersCount: 785,
// },
// {
// Id: 928,
// appName: "Aerified",
// appId: "140e1aa7-9276-406f-8ef2-4c1b03393c95",
// owner: "oziemkepr",
// usersCount: 376,
// },
// {
// Id: 929,
// appName: "It",
// appId: "e23216dd-c32c-4db9-bb57-24d8d5cafc87",
// owner: "mvanyushkinps",
// usersCount: 940,
// },
// {
// Id: 930,
// appName: "Home Ing",
// appId: "40032406-119b-4364-838f-32753490a129",
// owner: "nduxburypt",
// usersCount: 201,
// },
// {
// Id: 931,
// appName: "Bitwolf",
// appId: "55beb983-4b00-498f-957e-7c71fdb37c63",
// owner: "dperingpu",
// usersCount: 65,
// },
// {
// Id: 932,
// appName: "Zontrax",
// appId: "3f1cd07e-aa61-4bdd-8de8-40959b7af5e7",
// owner: "nmcgraffinpv",
// usersCount: 670,
// },
// {
// Id: 933,
// appName: "Zamit",
// appId: "d6588741-57b3-47e7-acc0-d4c7a9b2c4aa",
// owner: "cturbittpw",
// usersCount: 328,
// },
// {
// Id: 934,
// appName: "Redhold",
// appId: "bae7f7bf-a4ff-45a2-9208-77a6ac0724a9",
// owner: "mmarishenkopx",
// usersCount: 455,
// },
// {
// Id: 935,
// appName: "Span",
// appId: "181c8973-2d58-45a4-ba88-94268e7eaed0",
// owner: "kgunthorppy",
// usersCount: 864,
// },
// {
// Id: 936,
// appName: "Trippledex",
// appId: "4b820528-a097-4b1c-b2cf-f8bb4e15e038",
// owner: "kalonsopz",
// usersCount: 942,
// },
// {
// Id: 937,
// appName: "Holdlamis",
// appId: "e5c464e3-64bf-4e28-831b-16574ee329a5",
// owner: "bwhittallq0",
// usersCount: 329,
// },
// {
// Id: 938,
// appName: "Namfix",
// appId: "8910c044-1840-48ee-88de-81e60654e0b0",
// owner: "jvardieq1",
// usersCount: 606,
// },
// {
// Id: 939,
// appName: "Alpha",
// appId: "d9955ff1-9a4c-47bb-874f-9d14dc6592a7",
// owner: "mmuttittq2",
// usersCount: 15,
// },
// {
// Id: 940,
// appName: "Tin",
// appId: "772370fd-a44b-48da-bb6f-d9e7419f6e1d",
// owner: "amacallenq3",
// usersCount: 575,
// },
// {
// Id: 941,
// appName: "Gembucket",
// appId: "b91a3ee4-8062-4683-b848-1b643f6bc477",
// owner: "rkinkadeq4",
// usersCount: 656,
// },
// {
// Id: 942,
// appName: "Viva",
// appId: "754246fd-a93b-4079-a590-523436f882bc",
// owner: "csparkeq5",
// usersCount: 303,
// },
// {
// Id: 943,
// appName: "Tin",
// appId: "83eb6cbe-bd42-4e93-b837-a3ed2db78699",
// owner: "kitzkovwitchq6",
// usersCount: 400,
// },
// {
// Id: 944,
// appName: "Aerified",
// appId: "887bdfa4-ca06-477c-ba1f-278caca2fcd9",
// owner: "tleblancq7",
// usersCount: 943,
// },
// {
// Id: 945,
// appName: "Aerified",
// appId: "1701cd7c-c8bb-43f4-9e6f-ea29b6ca3491",
// owner: "dpiddlehintonq8",
// usersCount: 213,
// },
// {
// Id: 946,
// appName: "Span",
// appId: "caebb2b2-1f39-4ccb-a580-a42de3d3f703",
// owner: "kleekeq9",
// usersCount: 347,
// },
// {
// Id: 947,
// appName: "Redhold",
// appId: "28adf5b5-356b-450b-b1e5-2d1a3263c219",
// owner: "vyouensqa",
// usersCount: 847,
// },
// {
// Id: 948,
// appName: "Quo Lux",
// appId: "9246228d-8dc6-46a4-b23b-9e3f545c76dd",
// owner: "mbraniganqb",
// usersCount: 444,
// },
// {
// Id: 949,
// appName: "Sonsing",
// appId: "a19820b1-1201-454b-a265-fd9e4c119bc8",
// owner: "dguntripqc",
// usersCount: 505,
// },
// {
// Id: 950,
// appName: "Aerified",
// appId: "099bd231-156f-49da-bd06-4cc365a7e9a2",
// owner: "fgrimwadeqd",
// usersCount: 764,
// },
// {
// Id: 951,
// appName: "Sub-Ex",
// appId: "56c1c65c-0ae5-4be5-92dd-7277d13c9663",
// owner: "elewinqe",
// usersCount: 178,
// },
// {
// Id: 952,
// appName: "Subin",
// appId: "770291b9-8f83-490f-9a5b-3975f3db7bbc",
// owner: "kbullmanqf",
// usersCount: 622,
// },
// {
// Id: 953,
// appName: "Bytecard",
// appId: "8b83e623-cd2e-40a8-bac4-d997bcfbcf7f",
// owner: "kmorecombeqg",
// usersCount: 668,
// },
// {
// Id: 954,
// appName: "Y-find",
// appId: "23b17e42-e5a4-4d53-bf58-c8ed775210e2",
// owner: "dcaltonqh",
// usersCount: 272,
// },
// {
// Id: 955,
// appName: "Asoka",
// appId: "02882cb6-c664-4111-9dcf-61048d0fb4b7",
// owner: "hbatsfordqi",
// usersCount: 841,
// },
// {
// Id: 956,
// appName: "Quo Lux",
// appId: "ae826caa-121b-4c59-8fad-133fff7dc112",
// owner: "clownesqj",
// usersCount: 287,
// },
// {
// Id: 957,
// appName: "Ventosanzap",
// appId: "c8abb586-746a-4d2c-9dd9-af7c06169360",
// owner: "kgoundsyqk",
// usersCount: 655,
// },
// {
// Id: 958,
// appName: "Daltfresh",
// appId: "7226b3c8-1782-4169-a075-059c9bb5365f",
// owner: "fchesonql",
// usersCount: 668,
// },
// {
// Id: 959,
// appName: "Regrant",
// appId: "55939e9e-b787-4153-a9ee-d20f7ef0bbf1",
// owner: "jkuberaqm",
// usersCount: 49,
// },
// {
// Id: 960,
// appName: "Solarbreeze",
// appId: "b2af3e4b-2d43-45e4-8277-7b79f3d2b10e",
// owner: "nmoughtonqn",
// usersCount: 893,
// },
// {
// Id: 961,
// appName: "Aerified",
// appId: "267f6497-5a28-4339-a8f4-565dbc20d374",
// owner: "lbrianqo",
// usersCount: 419,
// },
// {
// Id: 962,
// appName: "Prodder",
// appId: "f9627095-a10e-41c8-8b66-348b2128fb1c",
// owner: "mayreeqp",
// usersCount: 687,
// },
// {
// Id: 963,
// appName: "Bitchip",
// appId: "664f301f-3d17-41e9-a1b4-38918f7bd59a",
// owner: "mrudigerqq",
// usersCount: 793,
// },
// {
// Id: 964,
// appName: "Treeflex",
// appId: "63aee6e8-aff9-4112-8ac9-5419c1fd6b87",
// owner: "hstihlqr",
// usersCount: 76,
// },
// {
// Id: 965,
// appName: "Zamit",
// appId: "2a92cbfe-7ddf-4dd2-b89d-db1d0c0b0424",
// owner: "dtorticeqs",
// usersCount: 160,
// },
// {
// Id: 966,
// appName: "Holdlamis",
// appId: "1fd4f864-a07c-492b-a803-b06bc4d97aa5",
// owner: "ahileyqt",
// usersCount: 788,
// },
// {
// Id: 967,
// appName: "Greenlam",
// appId: "ac3cf00f-cb6b-4634-bf2f-ae8ef12a3eb0",
// owner: "cdaddsqu",
// usersCount: 197,
// },
// {
// Id: 968,
// appName: "Gembucket",
// appId: "ac18b83a-0e0a-4bb4-8d57-b72dcc17758e",
// owner: "tjanjusevicqv",
// usersCount: 989,
// },
// {
// Id: 969,
// appName: "Home Ing",
// appId: "d4436e95-6ab2-4c58-bb17-41986aca482c",
// owner: "oboughtflowerqw",
// usersCount: 998,
// },
// {
// Id: 970,
// appName: "Sub-Ex",
// appId: "e518b282-2231-4036-8efe-770ef6cd70b9",
// owner: "dackermannqx",
// usersCount: 511,
// },
// {
// Id: 971,
// appName: "Overhold",
// appId: "18f8486a-d0c0-4576-9600-ffcd16ba1729",
// owner: "ebaigrieqy",
// usersCount: 992,
// },
// {
// Id: 972,
// appName: "Duobam",
// appId: "bef6fb8a-c544-4846-9d5b-b074b500d9ac",
// owner: "kecklyqz",
// usersCount: 260,
// },
// {
// Id: 973,
// appName: "Zaam-Dox",
// appId: "aad34366-a8ec-4c9e-927e-c4145a33adf9",
// owner: "tgiler0",
// usersCount: 798,
// },
// {
// Id: 974,
// appName: "Wrapsafe",
// appId: "7fdb6c13-d5d0-4c46-ae5a-d7168cdda17b",
// owner: "mivakhinr1",
// usersCount: 714,
// },
// {
// Id: 975,
// appName: "Bitwolf",
// appId: "7b8a6bfb-5f27-4d2c-9ae7-6a40feb9c834",
// owner: "tfelcer2",
// usersCount: 310,
// },
// {
// Id: 976,
// appName: "Prodder",
// appId: "1269083a-a3c5-4e69-be4f-fbbb409f418a",
// owner: "cdevilr3",
// usersCount: 478,
// },
// {
// Id: 977,
// appName: "Ronstring",
// appId: "c34c51f5-8bba-4807-a750-641285fd66e7",
// owner: "owanklinr4",
// usersCount: 315,
// },
// {
// Id: 978,
// appName: "Gembucket",
// appId: "538bcb67-6218-4da3-8a70-25742c062ad8",
// owner: "cdurnallr5",
// usersCount: 642,
// },
// {
// Id: 979,
// appName: "Vagram",
// appId: "4fd6bde3-ab37-4d61-81f4-669fb2443bc6",
// owner: "ataplinr6",
// usersCount: 601,
// },
// {
// Id: 980,
// appName: "Cookley",
// appId: "6c9f99b3-378d-40de-a359-5659fd1aa16c",
// owner: "trogerotr7",
// usersCount: 392,
// },
// {
// Id: 981,
// appName: "Vagram",
// appId: "0996d189-1676-43fe-9ec8-501eae848269",
// owner: "rrougierr8",
// usersCount: 618,
// },
// {
// Id: 982,
// appName: "Sub-Ex",
// appId: "4a511caf-191b-4164-b191-b3c7cda11339",
// owner: "mangeaur9",
// usersCount: 774,
// },
// {
// Id: 983,
// appName: "Zaam-Dox",
// appId: "42bca60e-ec94-4037-878d-8d2168abe8e6",
// owner: "cswatridgera",
// usersCount: 932,
// },
// {
// Id: 984,
// appName: "Flexidy",
// appId: "f7044b1d-43a8-4717-95b7-1f9764aad958",
// owner: "bbensonrb",
// usersCount: 817,
// },
// {
// Id: 985,
// appName: "Domainer",
// appId: "0b303741-5df3-4152-851c-182e8ffb98e9",
// owner: "clowtenrc",
// usersCount: 331,
// },
// {
// Id: 986,
// appName: "Fixflex",
// appId: "dff058b2-02ef-4e1b-9aef-96fdf80ac072",
// owner: "jguitonrd",
// usersCount: 21,
// },
// {
// Id: 987,
// appName: "Fix San",
// appId: "82a8fe6a-f423-4cac-83ae-52477b0e94d5",
// owner: "ebexleyre",
// usersCount: 889,
// },
// {
// Id: 988,
// appName: "Zamit",
// appId: "d2111976-bb78-4c80-8305-16d6339c6b51",
// owner: "amacveighrf",
// usersCount: 903,
// },
// {
// Id: 989,
// appName: "Toughjoyfax",
// appId: "784ac5eb-d0f4-44ee-92cd-26fadcd9682a",
// owner: "cohagertyrg",
// usersCount: 258,
// },
// {
// Id: 990,
// appName: "Solarbreeze",
// appId: "8c05ced2-d1b0-4091-8378-96967bbd2e8e",
// owner: "pcannellrh",
// usersCount: 469,
// },
// {
// Id: 991,
// appName: "Subin",
// appId: "a7d7ee0b-363a-421d-8d80-226964fd3cfb",
// owner: "cchansonri",
// usersCount: 965,
// },
// {
// Id: 992,
// appName: "Redhold",
// appId: "5ee7abbf-7638-418d-92ac-56967f17ce64",
// owner: "aeverleyrj",
// usersCount: 480,
// },
// {
// Id: 993,
// appName: "Daltfresh",
// appId: "5d0cf7b1-1779-43b8-9ba0-986bb5de1c5e",
// owner: "dtomaskunasrk",
// usersCount: 76,
// },
// {
// Id: 994,
// appName: "Cardify",
// appId: "1e0f278b-198d-4df7-9f08-21385084dfaa",
// owner: "pgrishukhinrl",
// usersCount: 843,
// },
// {
// Id: 995,
// appName: "It",
// appId: "1659f07d-ddfc-4cd4-bcc9-b553000cee08",
// owner: "bmanaghrm",
// usersCount: 677,
// },
// {
// Id: 996,
// appName: "Zontrax",
// appId: "c9a739c4-2d89-4d6d-bcd4-9c970b024c90",
// owner: "mfollittrn",
// usersCount: 513,
// },
// {
// Id: 997,
// appName: "Stim",
// appId: "bfb0b24a-a01e-44ad-898f-c71b1684dc3f",
// owner: "bbranchetro",
// usersCount: 845,
// },
// {
// Id: 998,
// appName: "Sonsing",
// appId: "542e9c2e-27fd-49d7-81b5-34f1cbcf5f04",
// owner: "sbellwoodrp",
// usersCount: 499,
// },
// {
// Id: 999,
// appName: "Trippledex",
// appId: "4eafc113-bf5f-42b0-8a50-2dfa96a92e3f",
// owner: "kewbanckrq",
// usersCount: 614,
// },
// {
// Id: 1000,
// appName: "Trippledex",
// appId: "58b30d87-1f40-4ab5-9953-da998e31813b",
// owner: "pwhittockrr",
// usersCount: 676,
// },
];
|
avbdev/siksha
|
client/src/utils/endpoints/index.ts
|
<reponame>avbdev/siksha
import axios from "axios";
import { DeleteEndPoint } from "./DeleteEndPoints";
import { GetEndPoints } from "./GetEndPoints";
import { PatchEndPoint } from "./PatchEndPoints";
import { PostEndPoint } from "./PostEndPoints";
export const getData = (endpoint: GetEndPoints) => {
return axios
.get(endpoint)
.then((res: any) => {
return res;
})
.catch((err) => {
return err;
});
};
export const postData = (endpoint: PostEndPoint) => {};
export const patchData = (endpoint: PatchEndPoint) => {};
export const deleteData = (endpoint: DeleteEndPoint) => {};
|
avbdev/siksha
|
client/src/components/atoms/Table/Utils.ts
|
export type PrimitiveType = string | number | boolean | Symbol;
export function ObjectValues<T extends {}>(obj: T) {
return Object.keys(obj).map((objKey) => obj[objKey as keyof T]);
}
export function isPrimitive(value: any): value is PrimitiveType {
return (
typeof value == "string" ||
typeof value == "number" ||
typeof value == "boolean" ||
typeof value == "symbol"
);
}
|
avbdev/siksha
|
client/src/components/pages/App/App.tsx
|
<filename>client/src/components/pages/App/App.tsx
import React, { useEffect, useState } from "react";
import { apps } from "../../../mock/mock";
import { getData } from "../../../utils/endpoints";
import { GetEndPoints } from "../../../utils/endpoints/GetEndPoints";
import { Table } from "../../atoms/Table/Table";
import { Toggle } from "../../atoms/Toggle/Toggle";
import "./App.css";
interface IApp {}
export const App: React.FC<IApp> = () => {
const styles = {};
const { Users } = GetEndPoints;
console.log("Statement 001");
console.log("Statement 002");
console.log("Statement 003");
console.log("Statement 004");
console.log("Statement 005");
useEffect(() => {
// const c = getData(Users);
// console.log(
// c.then((data) => {
// console.log("data", data);
// })
// );
console.log("Effect 001");
}, []);
useEffect(() => {
console.log("Effect 002");
}, []);
useEffect(() => {
console.log("Effect 003");
}, []);
useEffect(() => {
console.log("Effect 004");
}, []);
useEffect(() => {
console.log("Effect 005");
}, []);
return (
<div style={{ display: "flex", overflow: "hidden" }}>
<Sidebar />
<ContentArea />
</div>
);
};
interface ISidebar {}
const Sidebar: React.FC<ISidebar> = () => {
const styles = {
display: "flex",
minWidth: "200px",
maxHeight: "100vh",
height: "100vh",
background: "#161B30",
overflow: "hidden",
borderRadius: "5px",
};
return <div style={styles}>Sidebar</div>;
};
interface IContentArea {}
const ContentArea: React.FC<IContentArea> = () => {
const styles = {
display: "flex",
maxHeight: "100vh",
flex: 1,
// background: "red",
height: "100vh",
zIndex: 1,
borderRadius: "5px",
// overflow: "hidden",
};
const [isToggled, setIsToggled] = useState<boolean>(true);
return (
<div style={styles}>
{/* Content Area */}
{/* <Table /> */}
<Table items={apps} />
{/* <Toggle /> */}
<Toggle
rounded
isToggled={isToggled}
onToggle={() => setIsToggled(!isToggled)}
/>
</div>
);
};
|
avbdev/siksha
|
client/src/utils/endpoints/GetEndPoints.ts
|
export enum GetEndPoints {
Users = "https://randomuser.me/api/?results=20",
}
|
avbdev/siksha
|
client/src/components/atoms/Toggle/Toggle.tsx
|
<filename>client/src/components/atoms/Toggle/Toggle.tsx
import React from "react";
import cx from "classnames";
import "./Toggle.css";
interface IToggleProps {
rounded?: boolean;
isToggled?: boolean;
onToggle?: () => void;
}
export const Toggle: React.FC<IToggleProps> = (props) => {
const { rounded, isToggled, onToggle } = props;
const sliderCx = cx("slider", { rounded: rounded });
return (
<label className="toggle">
<input type="checkbox" checked={isToggled} onChange={onToggle} />
<span className={sliderCx}></span>
</label>
);
};
|
alecharl/clientes-app
|
src/app/app.component.ts
|
import { Component } from '@angular/core';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Bienvenidos a clientes-app';
curso: string = 'Curso Spring 5 con Angular 7';
autor: string = '<NAME>';
}
|
shujer/tree-utils
|
src/index.ts
|
<reponame>shujer/tree-utils<filename>src/index.ts
export { buildTree } from "./buildTree";
export { flattenTree } from "./flattenTree";
|
shujer/tree-utils
|
src/buildTree.ts
|
<reponame>shujer/tree-utils
export const buildTree = <
ID extends string,
PID extends string,
T extends { [key in ID | PID]: string }
>(
items: T[],
idKey: ID,
parentKey: PID,
rootVal?: string,
sort?: (a: T, b: T) => -1 | 1 | 0
) => {
type Wrapper = Map<string, T[]>;
type TreeNode = T & { children?: TreeNode[] };
const parnetWrap = (items: T[]): Wrapper => {
let parnetWrapper: Wrapper = new Map();
items.forEach((item) => {
if (parnetWrapper.has(item[parentKey])) {
let children = parnetWrapper.get(item[parentKey]) as T[];
children.push(item);
} else {
parnetWrapper.set(item[parentKey], [item]);
}
});
return parnetWrapper;
};
const topLevelWrap = (items: T[]): T[] => {
if (rootVal) {
return items.filter((ele) => ele[parentKey] === rootVal);
} else {
return items.filter(
//@ts-ignore
(parent) => !items.find((item) => item[idKey] === parent[parentKey])
);
}
};
const build = (topLevel: T[], wrapper: Wrapper): TreeNode[] => {
return topLevel.map((item) => {
if (wrapper.has(item[idKey])) {
let children = build(wrapper.get(item[idKey]) as TreeNode[], wrapper);
if (sort) {
children = children.sort(sort);
}
return {
...item,
children,
};
} else {
return item;
}
});
};
const parnetWrapper = parnetWrap(items);
const topLevelWrapper = topLevelWrap(items);
return build(topLevelWrapper, parnetWrapper);
};
|
shujer/tree-utils
|
src/flattenTree.ts
|
<reponame>shujer/tree-utils<gh_stars>1-10
export type TreeNode<CID extends string, T> = T &
{ [key in CID]?: TreeNode<CID, T>[] };
export const flattenTree = <
CID extends string,
T extends { [key in CID]?: TreeNode<CID, T>[] }
>(
items: TreeNode<CID, T>[],
childrenKey: CID = "children" as CID
) => {
const flattenOptions: T[] = [];
dfs(items);
return flattenOptions;
function dfs(nodes?: T[]) {
if (nodes == null) {
return;
}
for (const node of nodes) {
if (!node[childrenKey] || !node[childrenKey]!.length) {
flattenOptions.push(node);
} else {
dfs(node[childrenKey]);
}
}
}
};
|
Pandawan/yave
|
src/base/components/scale.ts
|
<gh_stars>1-10
import { Component } from '@trixt0r/ecs';
import { Vector } from '../../utils';
/**
* Scale Component to represent an entity's scale/size in world space.
*/
export class Scale extends Vector implements Component {
/**
* Scale on the x axis.
*/
public declare x: number;
/**
* Scale on the y axis.
*/
public declare y: number;
/**
* Scale on the z axis.
*/
public declare z: number;
/**
* Create a scale component with default values of 1.
*/
constructor();
/**
* Create a scale component, applying the same value to all three directions.
*/
constructor(value: number);
/**
* Create a 2D scale component.
*/
constructor(x: number, y: number);
/**
* Create a 3D scale component.
*/
constructor(x: number, y: number, z: number);
/**
* Create a scale component from the given vector.
*/
constructor(vector: Vector);
constructor(x?: number | Vector, y?: number, z?: number) {
// If a vector is passed, reassign x, y, z to the vector values
if (x instanceof Vector) {
const vec = x;
x = vec.x;
z = vec.z;
y = vec.y;
}
// If only x is assigned, set it to all directions
if (x !== undefined && y === undefined && z === undefined) {
super(x, x, x);
} else {
// Otherwise, it will auto-set x, y, and z based on passed parameters
super(x ?? 1, y ?? 1, z ?? 1);
}
}
}
|
Pandawan/yave
|
src/rendering/index.ts
|
export * from './components/camera';
export * from './components/spriteRendering';
export * from './components/textRendering';
export * from './systems/cameraRenderer';
export * from './systems/framerateCounter';
export * from './systems/pixiRenderer';
export * from './pixiRenderingEngine';
export * from './renderingEngine';
|
Pandawan/yave
|
src/index.ts
|
export * from './engine';
export * from './base';
export * from './ecs';
export * from './extras/tilemap';
export * from './rendering';
export * from './utils';
|
Pandawan/yave
|
src/lib/tilemapPatch.ts
|
<reponame>Pandawan/yave
// eslint-disable-next-line
declare namespace PIXI.tilemap {
interface CompositeRectTileLayer {
addResizeableFrame(
texture_: PIXI.Texture | string | number,
x: number,
y: number,
tileWidth?: number,
tileHeight?: number,
animX?: number,
animY?: number
): boolean;
}
}
/**
* This is a simple patch for the pixi-tilemap which adds support for resizeable frame (width & height)
* while keeping the (Texture | string | number) identification which is lost when using addRect.
*/
PIXI.tilemap.CompositeRectTileLayer.prototype.addResizeableFrame = function addResizeableFrame(
texture_: PIXI.Texture | string | number,
x: number,
y: number,
tileWidth?: number,
tileHeight?: number,
animX?: number,
animY?: number
): boolean {
let texture: PIXI.Texture;
let layer: PIXI.tilemap.RectTileLayer | null = null;
let ind = 0;
const children = this.children;
if (typeof texture_ === 'number') {
const childIndex = (texture_ / this.texPerChild) >> 0;
layer = children[childIndex] as PIXI.tilemap.RectTileLayer;
if (layer === null) {
layer = children[0] as PIXI.tilemap.RectTileLayer;
if (layer === null) {
return false;
}
ind = 0;
} else {
ind = texture_ % this.texPerChild;
}
texture = layer.textures[ind];
} else {
if (typeof texture_ === 'string') {
texture = PIXI.Texture.from(texture_);
} else {
texture = texture_ as PIXI.Texture;
}
for (let i = 0; i < children.length; i++) {
const child = children[i] as PIXI.tilemap.RectTileLayer;
const tex = child.textures;
for (let j = 0; j < tex.length; j++) {
if (tex[j].baseTexture === texture.baseTexture) {
layer = child;
ind = j;
break;
}
}
if (layer !== null) {
break;
}
}
if (layer === null) {
for (let i = 0; i < children.length; i++) {
const child = children[i] as PIXI.tilemap.RectTileLayer;
if (child.textures.length < this.texPerChild) {
layer = child;
ind = child.textures.length;
child.textures.push(texture);
break;
}
}
if (layer === null) {
layer = new PIXI.tilemap.RectTileLayer(this.zIndex, texture);
layer.compositeParent = true;
layer.offsetX = PIXI.tilemap.Constant.boundSize;
layer.offsetY = PIXI.tilemap.Constant.boundSize;
children.push(layer);
ind = 0;
}
}
}
layer.addRect(
ind,
texture.frame.x,
texture.frame.y,
x,
y,
tileWidth ?? texture.orig.width,
tileHeight ?? texture.orig.height,
animX,
animY,
texture.rotate
);
return true;
};
|
Pandawan/yave
|
src/rendering/pixiRenderingEngine.spec.ts
|
<filename>src/rendering/pixiRenderingEngine.spec.ts
import { PixiRenderingEngine } from './pixiRenderingEngine';
import PIXI, { Viewport } from '../lib/pixi';
import { Vector } from '../utils';
describe('PixiRendering', () => {
beforeEach(() => {
document.body.innerHTML = '<div id="game"></div>';
PIXI.utils.skipHello();
});
describe('initial', () => {
it('should have a null renderingEngine', () => {
const pixiRendering = new PixiRenderingEngine('game');
expect(pixiRendering.renderingEngine).toBeNull();
});
});
describe('initialization', () => {
it('should create a new Pixi Application', () => {
const pixiRendering = new PixiRenderingEngine('game');
pixiRendering.init();
expect(pixiRendering.renderingEngine).toBeInstanceOf(PIXI.Application);
});
});
describe('resource loading', () => {
it('should wait for the loader to load', async () => {
const pixiRendering = new PixiRenderingEngine('game');
pixiRendering.loader.load = jest.fn((cb: Function) => {
cb();
}) as any;
await pixiRendering.load();
});
});
describe('rendering', () => {
it('should tell the renderingEngine to render', () => {
const pixiRendering = new PixiRenderingEngine('game');
pixiRendering.renderingEngine = {
render: jest.fn(),
} as any;
pixiRendering.world = {
update: jest.fn(),
} as any;
pixiRendering.render(1);
expect(pixiRendering.renderingEngine?.render).toBeCalled();
expect(pixiRendering.world?.update).toBeCalled();
});
});
describe('position conversion', () => {
it('should convert a screen to world position', () => {
const pixiRendering = new PixiRenderingEngine('game');
pixiRendering.world = new Viewport({
screenWidth: 400, // Screen 400x300
screenHeight: 300,
noTicker: true,
});
const screenPos = new Vector(100, 100);
expect(pixiRendering.screenToWorldPosition(screenPos)).toMatchObject({
x: 100,
y: 100,
z: 0,
});
pixiRendering.world.moveCorner(150, 150); // Move top left corner by 100
expect(pixiRendering.screenToWorldPosition(screenPos)).toMatchObject({
x: 250,
y: 250,
z: 0,
});
});
it('should convert a world to screen position', () => {
const pixiRendering = new PixiRenderingEngine('game');
pixiRendering.world = new Viewport({
screenWidth: 400, // Screen 400x300
screenHeight: 300,
noTicker: true,
});
const worldPos = new Vector(100, 100);
expect(pixiRendering.worldToScreenPosition(worldPos)).toMatchObject({
x: 100,
y: 100,
z: 0,
});
pixiRendering.world.moveCorner(150, 150); // Move top left corner by 100
expect(pixiRendering.worldToScreenPosition(worldPos)).toMatchObject({
x: -50,
y: -50,
z: 0,
});
});
});
});
|
Pandawan/yave
|
src/base/components/position.ts
|
import { Component } from '@trixt0r/ecs';
import { Vector } from '../../utils';
/**
* Position Component to represent an entity's position in world space.
*/
export class Position extends Vector implements Component {
/**
* Position on the x axis.
*/
public declare x: number;
/**
* Position on the y axis.
*/
public declare y: number;
/**
* Position on the z axis.
*/
public declare z: number;
/**
* Create a position component with default values of 0.
*/
constructor();
/**
* Create a 2D position component.
*/
constructor(x: number, y: number);
/**
* Create a 3D position component.
*/
constructor(x: number, y: number, z: number);
/**
* Create a position component from the given vector.
*/
constructor(vector: Vector);
constructor(x: number | Vector = 0, y = 0, z = 0) {
// If a vector is passed, reassign x, y, z to the vector values
if (x instanceof Vector) {
const vec = x;
x = vec.x;
z = vec.z;
y = vec.y;
}
super(x, y, z);
}
}
|
Pandawan/yave
|
src/rendering/systems/pixiRenderer.ts
|
<filename>src/rendering/systems/pixiRenderer.ts<gh_stars>1-10
import { ComponentClass } from '@trixt0r/ecs';
import { YaveEntityRenderingSystem, YaveEntity } from '@/ecs';
import { SpriteRendering } from '../components/spriteRendering';
import { PixiRendering } from '../components/pixiRendering';
import { TextRendering } from '../components/textRendering';
import { TilemapRendering } from '@/extras/tilemap/components/tilemapRendering';
import { Position, Rotation, Scale } from '@/base';
const defaultSupportedRenderingComponents: ComponentClass<PixiRendering>[] = [
SpriteRendering,
TextRendering,
TilemapRendering,
];
/**
* Rendering System for SpriteRendering and TextRendering component.
*/
export class PixiRenderer extends YaveEntityRenderingSystem {
/**
* An internal list of the rendering components that are supported by this system.
* (This should not be changed after being set in the constructor).
*/
private readonly supportedRenderingComponents: ReadonlyArray<
ComponentClass<PixiRendering>
>;
/**
* Rendering System for SpriteRendering and TextRendering component.
* @param supportedRenderingComponents Which components (extending PixiRendering) should be rendered through this system.
* Use this when implementing custom rendering components that should behave the same as typical pixi rendering components.
*/
constructor(
supportedRenderingComponents = defaultSupportedRenderingComponents
) {
// Make sure passed components are actually supported
for (const component of supportedRenderingComponents) {
if (component.prototype instanceof PixiRendering === false) {
throw new Error(
`${component} does not extend PixiRendering. Only PixiRendering components are supported.`
);
}
}
super(undefined, [Position], undefined, supportedRenderingComponents);
this.supportedRenderingComponents = supportedRenderingComponents;
}
onAddedEntities(...entities: YaveEntity[]): void {
if (
this.yaveEngine === null ||
this.yaveEngine.rendering.renderingEngine === null
)
return;
for (const entity of entities) {
const pixiRenderingComponents = this.getPixiRenderingComponents(entity);
if (pixiRenderingComponents.length === 0)
throw new Error(
'Tried executing PixiRenderer system on entity without a PixiRendering component'
);
for (const pixiRendering of pixiRenderingComponents) {
if (
pixiRendering !== undefined &&
pixiRendering.addedToEngine === false
)
this.addToRenderingEngine(pixiRendering);
}
}
}
processEntity(entity: YaveEntity): void {
if (
this.yaveEngine === null ||
this.yaveEngine.rendering.renderingEngine === null
)
return;
const pixiRenderingComponents = this.getPixiRenderingComponents(entity);
if (pixiRenderingComponents.length === 0)
throw new Error(
'Tried executing PixiRenderer system on entity without a PixiRendering component'
);
for (const pixiRendering of pixiRenderingComponents) {
const position = entity.components.get(Position);
// Rotation, Pivot and Scale are not required so they could be undefined
const rotation = entity.components.get(Rotation) as Rotation | undefined;
const scale = entity.components.get(Scale) as Scale | undefined;
// Add the object to rendering engine if not already done
if (pixiRendering.addedToEngine === false)
this.addToRenderingEngine(pixiRendering);
// Update the pixiObj's position
pixiRendering.pixiObj.position.set(position.x, position.y);
// Update z index based on z position (See: https://pixijs.download/dev/docs/PIXI.Sprite.html#zIndex)
pixiRendering.pixiObj.zIndex = position.z;
// Update rotation if applicable
if (rotation !== undefined) {
pixiRendering.pixiObj.angle = rotation.z;
// TODO: Right now, pivot is from 0 to texture size, might want to set it from 0 to 1 by doing pivot * size
// TODO: Scale should be the same for all objects. An object with scale 1 should be the exact same size as another even with different texture sizes
pixiRendering.pixiObj.pivot.set(rotation.pivot.x, rotation.pivot.y);
}
// Update scale if applicable
if (scale !== undefined)
pixiRendering.pixiObj.scale.set(scale.x, scale.y);
}
}
private getPixiRenderingComponents(entity: YaveEntity): PixiRendering[] {
return this.supportedRenderingComponents
.map(componentClass => entity.components.get(componentClass))
.filter(component => component !== undefined && component !== null);
}
private addToRenderingEngine(pixiRendering: PixiRendering): void {
pixiRendering.pixiObj.sortableChildren = true; // TODO: This might not be a good idea (performance anc confusion for user)
this.yaveEngine?.rendering.world?.addChild(pixiRendering.pixiObj);
pixiRendering.addedToEngine = true;
}
}
|
Pandawan/yave
|
src/ecs/entity.spec.ts
|
import { YaveEntity } from './entity';
const uuidRegex = /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i;
describe('YaveEntity', () => {
const entity = new YaveEntity();
it('should have a pre-set uuid', () => {
expect(typeof entity.id).toBe('string');
expect(entity.id).toMatch(uuidRegex);
});
});
|
Pandawan/yave
|
src/utils/index.ts
|
/* Utils are not exported to package, they're mostly for internal purposes */
export * from './math';
export * from './vector';
|
Pandawan/yave
|
src/ecs/index.ts
|
<gh_stars>1-10
export * from './ecs';
export * from './entity';
export * from './entitySystem';
export * from './runOptions';
export * from './system';
// TODO: This is kind of dirty...
export * from '@trixt0r/ecs';
|
Pandawan/yave
|
src/ecs/system.ts
|
<filename>src/ecs/system.ts<gh_stars>1-10
import { System } from '@trixt0r/ecs';
import { RunOptions } from './runOptions';
import { YaveEngine } from '@/engine';
import { YaveECS } from './ecs';
/**
* Basic ECS System.
*/
export abstract class YaveSystem extends System {
/**
* The reference to the Yave engine.
*/
protected _yaveEngine: YaveEngine | null = null;
/**
* The reference to the ECS engine.
*/
protected _engine: YaveECS | null = null;
/**
* Whether or not this system should run in the render loop (instead of the tick loop).
*/
public readonly isRenderSystem: boolean = false;
/**
* The ECS engine this system is assigned to.
*/
get engine(): YaveECS | null {
return this._engine;
}
set engine(engine: YaveECS | null) {
super.engine = engine;
// Update yaveEngine property as well
if (engine !== null) this._yaveEngine = engine.yaveEngine;
}
/**
* The Yave engine this system is assigned to.
*/
get yaveEngine(): YaveEngine | null {
return this._yaveEngine;
}
/** @inheritdoc */
abstract process(options?: RunOptions): void | Promise<void>;
}
/**
* Basic ECS System meant to run during the Render loop.
*/
export abstract class YaveRenderingSystem extends YaveSystem {
/** @inheritdoc */
public readonly isRenderSystem = true;
}
|
Pandawan/yave
|
src/rendering/pixiRenderingEngine.ts
|
<filename>src/rendering/pixiRenderingEngine.ts
import PIXI, { Viewport } from '@/lib/pixi';
import { AbstractRendering } from './renderingEngine';
import { Vector } from '@/utils';
export class PixiRenderingEngine extends AbstractRendering<PIXI.Application> {
/**
* Resource Loader for PIXI
*/
public readonly loader: PIXI.Loader = new PIXI.Loader();
/**
* World object in Pixi stage.
* Make this the parent of all objects within the world.
*/
public world: Viewport | null = null;
init(): void {
// TODO: Might want to switch this to a PIXI.Renderer + PIXI.Container
this.renderingEngine = new PIXI.Application({
width: this.container.clientWidth,
height: this.container.clientHeight,
resizeTo: this.container,
autoDensity: true,
/*
* Retina devices render at twice the pixel size that they advertise, correct that by changing resolution
* NOTE: This means that you also need to create textures that are upscaled by 2 for retina
* (and have @2x somewhere in the path to the image for pixi to auto-set the Texture.resolution to 2)
* See: https://github.com/pixijs/pixi.js/issues/621 for more info
*/
resolution: window.devicePixelRatio,
/** Don't auto-render, let Yave's game loop handle it */
autoStart: false,
});
this.container.appendChild(this.renderingEngine.view);
// TODO: I'm not sure I need this viewport, I can probably handle this all myself
this.world = new Viewport({
screenWidth: this.container.clientWidth,
screenHeight: this.container.clientHeight,
noTicker: true,
interaction: this.renderingEngine.renderer.plugins.interaction,
});
// Tell world to auto-sort by zIndex
this.world.sortableChildren = true;
this.renderingEngine.stage.addChild(this.world);
// Auto-resize renderer & viewport/world whenever the window changes size
window.addEventListener('resize', () => {
if (this.renderingEngine !== null) {
this.renderingEngine.resize();
}
if (this.world !== null) {
this.world.resize(
this.container.clientWidth,
this.container.clientHeight
);
}
});
}
load(): Promise<void> {
// Create a promise that returns once the resource loader has finished loading.
return new Promise(resolve => {
this.loader.load(() => {
resolve();
});
});
}
render(dt: number): void {
if (this.renderingEngine !== null) {
if (this.world !== null) {
this.world.update(dt);
}
this.renderingEngine.render();
}
}
screenToWorldPosition(screenPosition: Vector): Vector {
if (this.world === null)
throw new Error('World has not yet been initialized.');
const pos = this.world?.toWorld(screenPosition.x, screenPosition.y);
return new Vector(pos?.x ?? 0, pos?.y ?? 0);
}
worldToScreenPosition(worldPosition: Vector): Vector {
if (this.world === null)
throw new Error('World has not yet been initialized.');
const pos = this.world?.toScreen(worldPosition.x, worldPosition.y);
return new Vector(pos?.x ?? 0, pos?.y ?? 0);
}
}
|
Pandawan/yave
|
src/engine.ts
|
import {
SignalDispatcher,
ISignal,
SimpleEventDispatcher,
ISimpleEvent,
} from 'strongly-typed-events';
import { YaveECS, RunOptions } from '@/ecs';
import { PixiRenderingEngine } from '@/rendering';
import { YaveInput, YaveInputOptions } from '@/input';
interface YaveEngineOptions {
/**
* How long (in ms) to wait between updates.
*/
timeStep: number;
/**
* After how many frames waiting to process should the engine skip them to catch up.
*/
skipFrameCount: number;
}
/**
* The main class for the Yave Engine.
*/
export class YaveEngine {
/**
* Current status of the engine.
*/
private _status: 'stopped' | 'running' | 'paused' = 'stopped';
/**
* ID of the requestAnimationFrame's callback.
* Used to stop the main loop.
*/
private _frameId: number | null = null;
/**
* Last time that the main loop executed.
*/
private _lastTime = 0;
/**
* How long (in ms) has it been since the last update was executed.
*/
private _accumulatedTime = 0;
/* Events */
private _onInit = new SignalDispatcher();
private _onStop = new SignalDispatcher();
// TODO: Should this use RunOptions instead of number (deltaTime)?
private _onUpdate = new SimpleEventDispatcher<number>();
// TODO: Should this use RunOptions instead of number (deltaTime)?
private _onRender = new SimpleEventDispatcher<number>();
/**
* The Entity Component System engine.
*/
public readonly ecs: YaveECS;
/**
* The Rendering engine.
*
* TODO: Find a way to make this generic in a clean way.
* I tried with YaveEngine<RenderingEngine extends AbstractRendering<any> = PixiRendering>
* but you also have to pass the object (or constructor) for PixiRendering to YaveEngine's constructor, which is ugly.
*/
public readonly rendering: PixiRenderingEngine;
/**
* The Input system.
*/
public readonly input: YaveInput;
/**
* How long (in ms) to wait between updates.
*/
public timeStep: number;
/**
* After how many frames waiting to process should the engine skip them to catch up.
*/
public skipFrameCount: number;
/**
* Create a YaveEngine instance.
* @param containerId The HTML #id of the container to render in.
* @param options Other options to setup the YaveEngine and its systems.
*/
constructor(
containerId = 'game',
options?: YaveEngineOptions & YaveInputOptions
) {
this.timeStep = options?.timeStep ?? 33;
this.skipFrameCount = options?.skipFrameCount ?? 10;
// Important sub-engines are setup here
this.ecs = new YaveECS(this);
this.rendering = new PixiRenderingEngine(containerId);
this.input = new YaveInput(containerId, options);
}
/**
* Get the engine's current status.
*/
public get status(): 'stopped' | 'running' | 'paused' {
return this._status;
}
/**
* Event called after the engine has been initialized.
*/
public get onInit(): ISignal {
return this._onInit.asEvent();
}
/**
* Event called before the engine is stopped.
*/
public get onStop(): ISignal {
return this._onStop.asEvent();
}
/**
* Event called before the engine has updated (with deltaTime).
*/
public get onUpdate(): ISimpleEvent<number> {
return this._onUpdate.asEvent();
}
/**
* Event called before the engine has rendered (with deltaTime).
*/
public get onRender(): ISimpleEvent<number> {
return this._onRender.asEvent();
}
/**
* Initialize the engine and start it.
* This will also call onInit.
*/
public async init(): Promise<void> {
if (this._status === 'running' || this._status === 'paused')
throw new Error('Engine is already running (or paused)');
this._status = 'running';
// Initialize the rendering engine
this.rendering.init();
// Load resources for rendering engine
await this.rendering.load();
// Initialize the Input system
this.input.init();
// Start the game loop
this.frame(performance.now());
this._onInit.dispatch();
}
/**
* Stop the engine entirely.
* This will also call onStop.
*/
public stop(): void {
if (this._status === 'stopped')
throw new Error('Engine is already stopped');
this._onStop.dispatch();
if (this._frameId !== null) {
// Stop the main loop entirely
cancelAnimationFrame(this._frameId);
this._frameId = null;
}
this.input.stop();
this._status = 'stopped';
}
/**
* Set the engine's pause status.
* @param paused Whether or not to pause the engine
*/
public setPaused(paused: boolean): void {
if (this._status === 'stopped')
throw new Error('Could not set paused status, Engine is stopped');
this._status = paused === true ? 'paused' : 'running';
}
/**
* The engine's main loop.
* Executes `update()` every `timeStep` and `render()` every browser animation frame.
* @param _time How long the engine has been running.
*/
private frame(_time: number): void {
// Stop the loop if status says to
if (this.status === 'stopped') return;
const currentTime = performance.now();
let deltaTime = Math.min(1000, currentTime - this._lastTime);
// If missed too many updates, skip all of them to catch up
// (usually happens when process has slept or CPU can't keep up)
if (deltaTime > this.timeStep * this.skipFrameCount) {
deltaTime = this.timeStep;
}
// Keep track of how long it has been since the last update
this._accumulatedTime += deltaTime;
this._lastTime = currentTime;
// If it has been more than {timeStep} since the last update, update as many times as possible to catch up
while (this._accumulatedTime >= this.timeStep) {
// this.time += this.step // This keeps track of how long the frame loop has been running
this._accumulatedTime -= this.timeStep;
this.update(this.timeStep);
}
// Render as often as rAF calls
this.render(deltaTime);
this._frameId = requestAnimationFrame(this.frame.bind(this));
}
/**
* Update the engine's non-rendering systems.
* @param delta Change in time since last update
*/
public update(delta: number): void {
// Don't update if paused
if (this.status === 'paused') return;
const runOptions: RunOptions = {
isRendering: false,
deltaTime: delta,
};
this._onUpdate.dispatch(delta);
// Run all systems
this.ecs.run(runOptions);
// Update the inputs value on update
this.input.update();
}
/**
* Update the engine's rendering systems.
* @param delta Change in time since last render
*/
public render(delta: number): void {
// Don't update if paused
if (this.status === 'paused') return;
const runOptions: RunOptions = {
isRendering: true,
deltaTime: delta,
};
this._onRender.dispatch(delta);
// Run all rendering systems
this.ecs.run(runOptions);
// Render the view with rendering engine
this.rendering.render(delta);
// Update the inputs value on render
this.input.render();
}
}
|
Pandawan/yave
|
src/input/normalize-wheel.d.ts
|
declare module 'normalize-wheel' {
/**
* Get normalized values of the scrollwheel event to be consistent between browsers and input device.
* This code tries to resolve a single slow step on a wheel to 1. (This does not mean the result will be between -1 and 1, simply that a reasonably slow scroll will be approximately 1).
*
* @see {@link https://github.com/basilfx/normalize-wheel/blob/master/src/normalizeWheel.js Source Code on GitHub} for more info
* @param event The wheel event to process.
*/
function normalizeWheel(
event: WheelEvent
): {
/**
* Normalized horizontal spin speed (use for zoom).
* Positive is right; negative is left.
*/
spinX: number;
/**
* Normalized vertical spin speed (use for zoom).
* Positive is down; negative is up.
*/
spinY: number;
/**
* Normalized horizontal distance (to pixels).
* Positive is right; negative is left.
*/
pixelX: number;
/**
* Normalized vertical distance (to pixels).
* Positive is down; negative is up.
*/
pixelY: number;
};
namespace normalizeWheel {
/**
* The best combination if you prefer spinX + spinY normalization. It favors
* the older DOMMouseScroll for Firefox, as FF does not include wheelDelta with
* 'wheel' event, making spin speed determination impossible.
*/
function getEventType(): 'wheel' | 'mousewheel' | 'DOMMouseScroll';
}
export = normalizeWheel;
}
|
Pandawan/yave
|
src/rendering/components/textRendering.ts
|
<filename>src/rendering/components/textRendering.ts
import PIXI from '@/lib/pixi';
import { PixiRendering } from './pixiRendering';
// NOTE: This is named TextRendering because "Text" name conflicts with pixi.js' Text and might be too confusing
export class TextRendering extends PixiRendering {
/**
* The PIXI.Text object.
*/
public textObject: PIXI.Text;
/**
* The text to render.
*/
public get text(): string {
return this.textObject.text;
}
public set text(value: string) {
this.textObject.text = value;
}
/**
* The style to render the text with.
*/
public get style(): PIXI.TextStyle {
return this.textObject.style;
}
public set style(value: PIXI.TextStyle) {
this.textObject.style = value;
}
// TODO: Kind of ugly, there's code duplication between spriteRendering and textRendering
/**
* The origin position of the texture (between 0 and 1).
* Note: This is different from pivot point.
*/
public get anchor(): PIXI.ObservablePoint {
return this.textObject.anchor;
}
public set anchor(value: PIXI.ObservablePoint) {
this.textObject.anchor = value;
}
/**
* The underlying generic PIXI object.
*/
public get pixiObj(): PIXI.Container {
return this.textObject;
}
constructor(text: string, fontSize: number, color: number);
constructor(text: string, style: PIXI.TextStyle);
constructor(text: PIXI.Text);
constructor(
text: string | PIXI.Text,
styleOrFontSize: number | PIXI.TextStyle = 16,
color = 0xffffff
) {
super();
if (text instanceof PIXI.Text) {
this.textObject = text;
return;
}
let style: PIXI.TextStyle = new PIXI.TextStyle();
if (typeof styleOrFontSize === 'number') {
style.fontSize = styleOrFontSize;
style.fill = color;
} else {
style = styleOrFontSize;
}
this.textObject = new PIXI.Text(text, style);
this.anchor.set(0.5, 0.5);
}
}
|
Pandawan/yave
|
src/ecs/ecs.spec.ts
|
import { YaveEngine } from '@/engine';
import { YaveECS } from './ecs';
import { YaveRenderingSystem, YaveSystem } from './system';
import { System } from '@trixt0r/ecs';
// Create a mock implementation of YaveEngine so it doesn't actually do anything
jest.mock('../engine');
class TestUnknownSystem extends System {
process = jest.fn();
}
class TestSystem extends YaveSystem {
process = jest.fn();
}
class TestRenderingSystem extends YaveRenderingSystem {
process = jest.fn();
}
describe('YaveECS', () => {
const mockEngine = new YaveEngine();
const ecs = new YaveECS(mockEngine);
it('should have a yaveEngine property', () => {
expect(ecs.yaveEngine).toBeInstanceOf(YaveEngine);
expect(ecs.yaveEngine).toBe(mockEngine);
});
describe('run', () => {
let unknownSystem: TestUnknownSystem;
let basicSystem: TestSystem;
let renderSystem: TestRenderingSystem;
beforeEach(() => {
unknownSystem = new TestUnknownSystem();
basicSystem = new TestSystem();
renderSystem = new TestRenderingSystem();
ecs.systems.add(unknownSystem, basicSystem, renderSystem);
});
/*
isRendering
Y N U
- - - - - - -
Y | O | X | X |
- - - - - - -
isRenderSystem N | X | O | O |
- - - - - - -
U | X | O | O |
- - - - - - -
*/
it('should run render systems only when isRendering is true', () => {
ecs.run({ deltaTime: 0, isRendering: true });
expect(renderSystem.process).toBeCalled(); // Only render is called
expect(basicSystem.process).not.toBeCalled();
expect(unknownSystem.process).not.toBeCalled();
});
it('should run normal and unknown systems when isRendering is false', () => {
ecs.run({ deltaTime: 0, isRendering: false });
expect(renderSystem.process).not.toBeCalled();
expect(unknownSystem.process).toBeCalled(); // Unknown is called
expect(basicSystem.process).toBeCalled(); // Basic is called
});
it('should run normal and unknown systems when options is undefined', () => {
ecs.run(undefined as any);
expect(renderSystem.process).not.toBeCalled();
expect(unknownSystem.process).toBeCalled(); // Unknown is called
expect(basicSystem.process).toBeCalled(); // Basic is called
});
it('should run normal and unknown systems when isRendering is undefined', () => {
ecs.run({ deltaTime: 0 } as any);
expect(renderSystem.process).not.toBeCalled();
expect(unknownSystem.process).toBeCalled(); // Unknown is called
expect(basicSystem.process).toBeCalled(); // Basic is called
});
});
});
|
Pandawan/yave
|
src/base/components/position.spec.ts
|
<gh_stars>1-10
import { Position } from './position';
import { Vector } from '../../utils';
describe('Position Component', () => {
describe('constructor', () => {
it('should work with empty parameters', () => {
const pos = new Position();
expect(pos.x).toBe(0);
expect(pos.y).toBe(0);
expect(pos.z).toBe(0);
});
it('should work with two parameters', () => {
const pos = new Position(1, 2);
expect(pos.x).toBe(1);
expect(pos.y).toBe(2);
expect(pos.z).toBe(0);
});
it('should work with three parameters', () => {
const pos = new Position(1, 2, 3);
expect(pos.x).toBe(1);
expect(pos.y).toBe(2);
expect(pos.z).toBe(3);
});
it('should work with a vector parameter', () => {
const vec = new Vector(1, 2, 3);
const pos = new Position(vec);
expect(pos.x).toBe(vec.x);
expect(pos.y).toBe(vec.y);
expect(pos.z).toBe(vec.z);
});
});
});
|
Pandawan/yave
|
src/utils/vector.spec.ts
|
import { Vector } from './vector';
describe('Vector', () => {
describe('constructor', () => {
it('should set default values when used with empty parameters', () => {
const v = new Vector();
expect(v.x).toBe(0);
expect(v.y).toBe(0);
expect(v.z).toBe(0);
});
it('should set x and y when used with two parameters', () => {
const v = new Vector(1, 2);
expect(v.x).toBe(1);
expect(v.y).toBe(2);
expect(v.z).toBe(0);
});
it('should set x, y, and z when used with three parameters', () => {
const v = new Vector(1, 2, 3);
expect(v.x).toBe(1);
expect(v.y).toBe(2);
expect(v.z).toBe(3);
});
});
describe('helpers', () => {
let v: Vector;
beforeEach(() => {
v = new Vector(1, 2, 3);
});
it('should set() values correctly', () => {
v.set(3, 4);
expect(v.x).toBe(3);
expect(v.y).toBe(4);
v.set(5, 6, 7);
expect(v.x).toBe(5);
expect(v.y).toBe(6);
expect(v.z).toBe(7);
});
it('should map() values correctly', () => {
let counter = 0;
v.map((value: number, index: number, vector: Vector) => {
expect(index).toBe(counter++); // counter = 0, 1, 2
expect(value).toBe(counter); // counter = 1, 2, 3 (after ++)
expect(vector).toBe(v);
return index + 3;
});
expect(v.x).toBe(3);
expect(v.y).toBe(4);
expect(v.z).toBe(5);
});
it('should round values correctly', () => {
v.x = 4.1;
v.y = 5.8;
v.z = 6.5;
v.round();
expect(v.x).toBe(4);
expect(v.y).toBe(6);
expect(v.z).toBe(7);
});
it('should floor values correctly', () => {
v.x = 4.1;
v.y = 5.8;
v.z = 6.5;
v.floor();
expect(v.x).toBe(4);
expect(v.y).toBe(5);
expect(v.z).toBe(6);
});
it('should ceil values correctly', () => {
v.x = 4.1;
v.y = 5.8;
v.z = 6.5;
v.ceil();
expect(v.x).toBe(5);
expect(v.y).toBe(6);
expect(v.z).toBe(7);
});
describe('type-manipulation', () => {
it('should create a new vector when cloning', () => {
expect(v.clone()).not.toBe(v);
});
it('should create a valid 3-element array by default', () => {
const arr = v.toArray();
expect(arr.length).toBe(3);
expect(arr[0]).toBe(1);
expect(arr[1]).toBe(2);
expect(arr[2]).toBe(3);
});
it('should create a valid 2-element array when enforcing 2d', () => {
const arr = v.toArray(true);
expect(arr.length).toBe(2);
expect(arr[0]).toBe(1);
expect(arr[1]).toBe(2);
});
it('should create a valid 3-element array when not enforcing 2d', () => {
const arr = v.toArray(false);
expect(arr.length).toBe(3);
expect(arr[0]).toBe(1);
expect(arr[1]).toBe(2);
expect(arr[2]).toBe(3);
});
it('should convert to a string', () => {
expect(v.toString()).toBe('(1, 2, 3)');
expect(v.toString(false)).toBe('(1, 2, 3)');
expect(v.toString(true)).toBe('(1, 2)');
});
it('should convert from a string', () => {
expect(Vector.fromString('(1)')).toMatchObject({
x: 1,
y: 0,
z: 0,
});
expect(Vector.fromString('(1, -2)')).toMatchObject({
x: 1,
y: -2,
z: 0,
});
expect(Vector.fromString('(1, -2, 3)')).toMatchObject({
x: 1,
y: -2,
z: 3,
});
// Error handling
expect(() => Vector.fromString('invalid argument')).toThrow();
expect(() => Vector.fromString('(1, 2, 3, 4)')).toThrow();
});
});
});
});
|
Pandawan/yave
|
src/ecs/entitySystem.spec.ts
|
<filename>src/ecs/entitySystem.spec.ts
import { YaveEngine } from '@/engine';
import { YaveECS } from './ecs';
import { YaveEntity } from './entity';
import { YaveEntitySystem, YaveEntityRenderingSystem } from './entitySystem';
import { Aspect, Component } from '@trixt0r/ecs';
import { RunOptions } from './runOptions';
// TODO: Clean up "Common" tests, they were taken directly from @trixt0r/ecs and are kind of messy
jest.mock('../engine');
class TestComponent1 implements Component {}
class TestComponent2 implements Component {}
class TestComponent3 implements Component {}
class TestComponent4 implements Component {}
// Tests taken from @trixt0r/ecs
describe('YaveEntitySystem (Common)', () => {
class TestEntitySystem extends YaveEntitySystem {
entities: YaveEntity[] = [];
processEntity(entity: YaveEntity): void {
this.entities.push(entity);
}
getAspect(): Aspect {
if (this.aspect === null) throw new Error('Aspect is null');
return this.aspect;
}
}
let mockEngine: YaveEngine;
let mockECS: YaveECS;
let mockRunOptions: RunOptions;
beforeEach(() => {
mockEngine = new YaveEngine();
mockECS = new YaveECS(mockEngine);
mockRunOptions = {
deltaTime: 0,
isRendering: false,
};
});
it('should process each entity in the engine', () => {
mockECS.entities.add(new YaveEntity(), new YaveEntity(), new YaveEntity());
const system = new TestEntitySystem();
mockECS.systems.add(system);
mockECS.run(mockRunOptions);
expect(system.entities.length).toBe(mockECS.entities.length);
mockECS.entities.forEach((entity: YaveEntity, i: number) => {
expect(system.entities[i]).toBe(entity);
});
});
it('should process each entity fitting the provided aspects', () => {
mockECS.entities.add(new YaveEntity(), new YaveEntity(), new YaveEntity());
mockECS.entities.elements[0].components.add(
new TestComponent1(),
new TestComponent2(),
new TestComponent4()
);
mockECS.entities.elements[1].components.add(
new TestComponent1(),
new TestComponent2(),
new TestComponent3()
);
mockECS.entities.elements[2].components.add(
new TestComponent1(),
new TestComponent2()
);
const system = new TestEntitySystem(
0,
[TestComponent1],
[TestComponent3],
[TestComponent4, TestComponent2]
);
mockECS.systems.add(system);
mockECS.run(mockRunOptions);
expect(system.entities.length).toBe(2);
});
it('should detach the aspect after removing the system from the engine', () => {
const system = new TestEntitySystem(
0,
[TestComponent1],
[TestComponent3],
[TestComponent4, TestComponent2]
);
mockECS.systems.add(system);
expect(system.getAspect()?.isAttached).toBe(true);
mockECS.systems.remove(system);
expect(system.getAspect()?.isAttached).toBe(false);
});
it('should call all entity and component related methods', () => {
const system = new TestEntitySystem();
mockECS.systems.add(system);
const methodsAndArgs = {
onAddedEntities: [new YaveEntity(), new YaveEntity(), new YaveEntity()],
onRemovedEntities: [new YaveEntity(), new YaveEntity(), new YaveEntity()],
onClearedEntities: [],
onSortedEntities: [],
onAddedComponents: [
new YaveEntity(),
[new TestComponent1(), new TestComponent2()],
],
onRemovedComponents: [
new YaveEntity(),
[new TestComponent1(), new TestComponent2()],
],
onClearedComponents: [new YaveEntity()],
onSortedComponents: [new YaveEntity()],
};
const keys = Object.keys(methodsAndArgs);
let calledTimes = 0;
keys.forEach((method: string) => {
let calledArgs: any[] | undefined = undefined;
const methodArgs = (methodsAndArgs as any)[method];
(system as any)[method] = function(...args: any[]) {
calledArgs = Array.prototype.slice.call(args);
};
(system.getAspect() as any).dispatch.apply(system.getAspect(), [
method,
...methodArgs,
]);
expect(calledArgs).toBeDefined();
expect(calledArgs).toEqual(methodArgs);
calledTimes++;
});
expect(calledTimes).toBe(keys.length);
});
});
describe('YaveEntitySystem', () => {
class TestEntitySystem extends YaveEntitySystem {
processEntity = jest.fn();
}
let system: TestEntitySystem;
beforeEach(() => {
system = new TestEntitySystem();
system.engine = { entities: { elements: [1], length: 1 } } as any;
});
it('should call the processEntity method when not in rendering mode', () => {
const runOptions: RunOptions = {
deltaTime: 5,
isRendering: false,
};
system.run(runOptions);
expect(system.processEntity).toBeCalled();
});
it('should not call the processEntity method when in rendering mode', () => {
const runOptions: RunOptions = {
deltaTime: 5,
isRendering: true,
};
system.run(runOptions);
expect(system.processEntity).not.toBeCalled();
});
});
describe('YaveEntityRenderingSystem', () => {
class TestEntityRenderingSystem extends YaveEntityRenderingSystem {
processEntity = jest.fn();
}
let system: TestEntityRenderingSystem;
beforeEach(() => {
system = new TestEntityRenderingSystem();
system.engine = { entities: { elements: [1], length: 1 } } as any;
});
it('should call the processEntity method when in rendering mode', () => {
const runOptions: RunOptions = {
deltaTime: 5,
isRendering: true,
};
system.run(runOptions);
expect(system.processEntity).toBeCalled();
});
it('should not call the processEntity method when not in rendering mode', () => {
const runOptions: RunOptions = {
deltaTime: 5,
isRendering: false,
};
system.run(runOptions);
expect(system.processEntity).not.toBeCalled();
});
});
|
Pandawan/yave
|
src/engine.spec.ts
|
<gh_stars>1-10
import { YaveEngine } from './index';
import { YaveECS } from './ecs';
import { AbstractRendering } from './rendering';
import PIXI from './lib/pixi';
describe('YaveEngine', () => {
let engine: YaveEngine;
beforeEach(() => {
document.body.innerHTML = '<div id="game"></div>';
engine = new YaveEngine();
PIXI.utils.skipHello();
});
describe('initial', () => {
it('should have an ECS instance', () => {
expect(engine.ecs).toBeInstanceOf(YaveECS);
});
it('should have an AbstractRendering instance', () => {
expect(engine.rendering).toBeInstanceOf(AbstractRendering);
});
it('should be stopped', () => {
expect(engine.status).toBe('stopped');
});
it('should not have any listeners', () => {
expect(engine.onInit.count).toBe(0);
expect(engine.onStop.count).toBe(0);
expect(engine.onUpdate.count).toBe(0);
});
it('should have a default timestep', () => {
expect(engine.timeStep).not.toBe(0);
});
it('should not be executing the game loop', () => {
expect((engine as any)._frameId).toBeNull();
});
});
describe('initialization', () => {
it('should call onInit after initialization', async () => {
const onInitSpy = jest.fn();
engine.onInit.subscribe(onInitSpy);
await engine.init();
expect(onInitSpy).toBeCalled();
});
it('should be running', async () => {
await engine.init();
expect(engine.status).toBe('running');
});
it('should be initializing the rendering engine', async () => {
engine.rendering.init = jest.fn();
await engine.init();
expect(engine.rendering.init).toBeCalled();
});
it('should load resources on the rendering engine', async () => {
engine.rendering.load = jest.fn();
await engine.init();
expect(engine.rendering.load).toBeCalled();
});
it('should be executing the game loop', async () => {
await engine.init();
expect(typeof (engine as any)._frameId).toBe('number');
});
it('should throw when trying to init while already running', async () => {
await engine.init();
expect(engine.init()).rejects.toThrow();
});
});
describe('pause', () => {
it('should be paused when calling setPaused(true) while running', async () => {
await engine.init();
engine.setPaused(true);
expect(engine.status).toBe('paused');
});
it('should be paused when calling setPaused(true) while already paused', async () => {
await engine.init();
engine.setPaused(true);
engine.setPaused(true);
expect(engine.status).toBe('paused');
});
it('should be running when calling setPaused(false) while paused', async () => {
await engine.init();
engine.setPaused(true);
engine.setPaused(false);
expect(engine.status).toBe('running');
});
it('should be running when calling setPaused(false) while already running', async () => {
await engine.init();
engine.setPaused(false);
expect(engine.status).toBe('running');
});
it('should throw an error when calling setPaused while stopped', () => {
expect(() => engine.setPaused(false)).toThrow();
expect(() => engine.setPaused(true)).toThrow();
});
});
describe('update', () => {
it('should call onUpdate on every update', async done => {
const onUpdateSpy = jest.fn((delta: number | undefined) => {
// Check that the parameter passed is a number
expect(typeof delta).toBe('number');
done();
});
engine.onUpdate.subscribe(onUpdateSpy);
await engine.init();
});
});
describe('render', () => {
it('should call onRender on every render', async done => {
const onRenderSpy = jest.fn((delta: number | undefined) => {
// Check that the parameter passed is a number
expect(typeof delta).toBe('number');
done();
});
engine.onRender.subscribe(onRenderSpy);
await engine.init();
});
it("should call the rendering engine's render function", async () => {
engine.rendering.render = jest.fn();
await engine.init();
expect(engine.rendering.render).toBeCalled();
});
});
describe('stop', () => {
it('should call onStop before stopping', async () => {
const onStopSpy = jest.fn();
engine.onStop.subscribe(onStopSpy);
await engine.init();
engine.stop();
expect(onStopSpy).toBeCalled();
});
it('should be stopped', async () => {
await engine.init();
engine.stop();
expect(engine.status).toBe('stopped');
});
it('should not be executing the game loop', async () => {
await engine.init();
engine.stop();
expect((engine as any)._frameId).toBeNull();
});
it('should throw when trying to stop while already stopped', async () => {
await engine.init();
engine.stop();
expect(() => engine.stop()).toThrow();
});
});
});
|
Pandawan/yave
|
src/input/input.ts
|
import normalizeWheel from 'normalize-wheel';
import { Vector } from '@/utils';
interface KeyBindings {
/**
* Binding of keycode to an array of [ virtualKeyCodes ]
*/
[keyCode: string]: string[];
}
interface KeyStates {
/**
* State of given key (true for active)
*/
[virtualKeyCode: string]: {
/**
* Whether or not the key is currently being pressed.
*/
down: boolean;
/**
* Whether or not the key is currently being held down instead of just pressed.
*/
held: boolean;
};
}
interface CursorState {
// TODO: spec.ts file
/**
* Current position (in pixels) of the cursor relative to the game container.
*/
position: Vector;
/**
* Change in position (in pixels) of the cursor (since last render frame) relative to the game container.
*/
delta: Vector;
/**
* Change in scrolling (since last update frame).
* A reasonably slow scroll will be approximately 1.
* Positive is down/right; negative is up/left.
*/
scroll: Vector;
/**
* Whether or not the pointer is currently locked.
*/
locked: boolean;
}
export interface YaveInputOptions {
/**
* Whether or not to automatically lock the cursor when entering the game view.
*/
lockCursor: boolean;
/**
* Whether or not to automatically register default bindings for a simpler setup.
*/
registerDefaultBindings: boolean;
}
export class YaveInput {
/**
* Whether or not to automatically lock the cursor when clicking the game view.
*/
public lockCursor: boolean;
private readonly _bindings: KeyBindings;
private readonly _keys: KeyStates;
private readonly _cursor: CursorState;
// TODO: Touch events (simply add an extra set of event listeners)
private _container: HTMLElement;
/**
* Current keys state.
* Use this to get the current input state of registered key binds.
*/
public get keys(): Readonly<KeyStates> {
return this._keys;
}
/**
* Current cursor state.
*/
public get cursor(): Readonly<CursorState> {
return this._cursor;
}
/**
* Create a YaveInput instance.
* @param containerId The HTML #id of the container to handle input events from.
* @param options Other options to setup the YaveInput system.
*/
constructor(containerId: string, options?: YaveInputOptions) {
const container = document.getElementById(containerId);
if (container === null || container === undefined)
throw new Error(`Could not find an element with id ${containerId}`);
this._container = container;
this._bindings = {};
this._keys = {};
this.lockCursor = options?.lockCursor ?? true;
this._cursor = {
position: new Vector(),
delta: new Vector(),
scroll: new Vector(),
locked: false,
};
// Options = undefined, or registerDefaultBindings = undefined or true
if (options?.registerDefaultBindings !== false) {
this.registerDefaultBindings();
}
this.onKeyDownEvent = this.onKeyDownEvent.bind(this);
this.onKeyUpEvent = this.onKeyUpEvent.bind(this);
this.onMouseDownEvent = this.onMouseDownEvent.bind(this);
this.onMouseUpEvent = this.onMouseUpEvent.bind(this);
this.onMouseMoveEvent = this.onMouseMoveEvent.bind(this);
this.onMouseWheelEvent = this.onMouseWheelEvent.bind(this);
this.onContextMenu = this.onContextMenu.bind(this);
this.onClickContainer = this.onClickContainer.bind(this);
}
/**
* Initialize the input system, registering all key event listeners.
*/
public init(): void {
window.addEventListener('keydown', this.onKeyDownEvent, false);
window.addEventListener('keyup', this.onKeyUpEvent, false);
// All mouse events are relative to this._container so that mouse x/y isn't offset if container isn't full screen
this._container.addEventListener('mousedown', this.onMouseDownEvent, false);
this._container.addEventListener('mouseup', this.onMouseUpEvent, false);
this._container.addEventListener('mousemove', this.onMouseMoveEvent, false);
this._container.addEventListener(
normalizeWheel.getEventType() as any, // TypeScript doesn't like mousewheel & DOMMouseScroll
this.onMouseWheelEvent
);
this._container.oncontextmenu = this.onContextMenu;
this._container.addEventListener('click', this.onClickContainer, false);
}
/**
* Update event, cleans up update-related values
*/
public update(): void {
this._cursor.scroll.x = 0;
this._cursor.scroll.y = 0;
}
/**
* Render event, cleans up rendering-related values
*/
public render(): void {
// If currently locked, but don't want it locked, stop it immediately
if (this._cursor.locked === true && this.lockCursor === false) {
document.exitPointerLock();
}
// Cursor movement is more "visible" so it's updated on render
this._cursor.delta.x = 0;
this._cursor.delta.y = 0;
}
/**
* Clean up the input system, disabling all key event listeners.
*/
public stop(): void {
window.removeEventListener('keydown', this.onKeyDownEvent);
window.removeEventListener('keyup', this.onKeyUpEvent);
this._container.removeEventListener('mousedown', this.onMouseDownEvent);
this._container.removeEventListener('mousemove', this.onMouseMoveEvent);
this._container.removeEventListener(
normalizeWheel.getEventType() as any, // TypeScript doesn't like mousewheel & DOMMouseScroll
this.onMouseWheelEvent
);
this._container.oncontextmenu = null;
this._container.removeEventListener('click', this.onClickContainer);
}
//#region Event Handler
private getKeyCode(event: KeyboardEvent | MouseEvent): string {
// Keyboard Press
if (event instanceof KeyboardEvent) {
// Space bar is weird and returns an actual space character
if (event.key === ' ' || event.key === 'Spacebar') return 'space';
return event.key.toLowerCase();
}
// Mouse Button Press
else if (event instanceof MouseEvent) {
return `mouse${event.button + 1}`;
}
return '';
}
private onKeyDownEvent(event: KeyboardEvent): boolean {
const keyCode = this.getKeyCode(event);
this.handleKeyEvent(keyCode, true);
// TODO: Find a way to detect if modifier (meta/shift/alt) keys are being held down
// Don't want to move between elements
if (keyCode === 'tab') {
event.preventDefault();
return false;
}
return true;
}
private onKeyUpEvent(event: KeyboardEvent): boolean {
const keyCode = this.getKeyCode(event);
this.handleKeyEvent(keyCode, false);
// Don't want to move between elements
if (keyCode === 'tab') {
event.preventDefault();
return false;
}
return true;
}
private onMouseDownEvent(event: MouseEvent): void {
const keyCode = this.getKeyCode(event);
this.handleKeyEvent(keyCode, true);
}
private onMouseUpEvent(event: MouseEvent): void {
const keyCode = this.getKeyCode(event);
this.handleKeyEvent(keyCode, false);
}
private onMouseWheelEvent(event: WheelEvent | MouseWheelEvent): boolean {
const wheelData = normalizeWheel(event);
this._cursor.scroll.x = wheelData.spinX;
this._cursor.scroll.y = wheelData.spinY;
// Prevent scroll event from scrolling through webpage (rubberbanding and such)
event.preventDefault();
return false;
}
/**
* Handle the state change of the key.
* @param keyCode The key that is being modified.
* @param state The state of the key being modified.
*/
private handleKeyEvent(keyCode: string, state: boolean): void {
const virtualKeyCodes = this._bindings[keyCode];
if (virtualKeyCodes === undefined) return;
for (const virtualKeyCode of virtualKeyCodes) {
const previouslyDown = this._keys[virtualKeyCode].down;
this._keys[virtualKeyCode] = {
down: state,
// Held only if it was previously down and it currently is down
held: previouslyDown && state,
};
}
}
private onContextMenu(): boolean {
// Cancel context menu if there's a binding for right mouse button
if (this._bindings['mouse3'] !== undefined) {
return false;
}
return true;
}
private onMouseMoveEvent(event: MouseEvent): void {
this._cursor.delta.x += event.movementX ?? (event as any).mozMovementX ?? 0;
this._cursor.delta.y += event.movementY ?? (event as any).mozMovementY ?? 0;
this._cursor.position.x = event.clientX;
this._cursor.position.y = event.clientY;
}
private onClickContainer(_event: MouseEvent): void {
// When click game view & want pointer lock but not locked yet, try to lock
if (this.lockCursor === true && this._cursor.locked === false) {
this._container.requestPointerLock();
}
}
//#endregion Event Handler
/**
* Register default key bindings.
*/
public registerDefaultBindings(): void {
this.addBinding('up', 'w', 'arrowup')
.addBinding('down', 's', 'arrowdown')
.addBinding('left', 'a', 'arrowleft')
.addBinding('right', 'd', 'arrowright')
.addBinding('fire', 'mouse1')
.addBinding('alt', 'mouse3');
}
/**
* Add a key binding.
* @param name The name of the input binding.
* @param keyCodes The keycodes for the keys that should trigger this binding.
* @returns The current YaveInput object.
*/
public addBinding(name: string, ...keyCodes: string[]): YaveInput {
for (const keyCode of keyCodes.map((code: string) => code.toLowerCase())) {
if (this._bindings[keyCode] === undefined) this._bindings[keyCode] = [];
if (this._bindings[keyCode].indexOf(name) !== -1)
throw new Error(
`Input binding ${name} already exists for key ${keyCode}`
);
this._bindings[keyCode].push(name);
}
this._keys[name] = { down: false, held: false };
return this;
}
/**
* Remove an existing key binding.
* @param name The name of the input binding to remove.
* @returns The current YaveInput object.
*/
public removeBinding(name: string): YaveInput {
for (const virtualKeyCodes of Object.values(this._bindings)) {
const index = virtualKeyCodes.indexOf(name);
if (index !== -1) virtualKeyCodes.splice(index, 1);
}
delete this._keys[name];
return this;
}
}
|
Pandawan/yave
|
src/rendering/renderingEngine.ts
|
<gh_stars>1-10
import { Vector } from '@/utils';
export abstract class AbstractRendering<T> {
public renderingEngine: T | null = null;
/**
* HTML Element to render in.
*/
protected readonly container: HTMLElement;
/**
* Create a Rendering Engine.
* @param containerId The HTML #id of the container to create the rendering engine in.
*/
constructor(containerId: string) {
const container = document.getElementById(containerId);
if (container === null)
throw new Error(`Could not find an element with id ${containerId}`);
this.container = container;
}
/**
* Called on initialization of YaveEngine.
* Use this to implement any rendering engine setup.
*/
abstract init(): void;
/**
* Called after initialization of Rendering.
* Use this to implement any resource loading.
*/
abstract load(): Promise<void>;
/**
* Called after calling all render systems.
* Use this to actually render the view.
* @param dt Change in time since last frame
*/
abstract render(dt: number): void;
/**
* Converts the given screen position to a world position.
* @param screenPosition A position in screen coordinates.
*/
abstract screenToWorldPosition(screenPosition: Vector): Vector;
/**
* Converts the given world position to a screen position.
* @param worldPosition A position in world coordinates.
*/
abstract worldToScreenPosition(worldPosition: Vector): Vector;
}
|
Pandawan/yave
|
src/rendering/systems/pixiRenderer.spec.ts
|
<gh_stars>1-10
import { YaveEntity } from '@/ecs/entity';
import { PixiRenderer } from './pixiRenderer';
import PIXI from '@/lib/pixi';
import { Position, Rotation, Scale } from '@/base';
import { SpriteRendering } from '../components/spriteRendering';
import { TextRendering } from '../components/textRendering';
import { PixiRendering } from '../components/pixiRendering';
describe('PixiRenderer', () => {
let mockEntity: YaveEntity;
let pixiRenderer: PixiRenderer;
beforeEach(() => {
document.body.innerHTML = '<div id="game"></div>';
pixiRenderer = new PixiRenderer();
(pixiRenderer as any)._yaveEngine = {
rendering: {
world: {
addChild: jest.fn(),
},
},
};
});
// Test cases to run generic tests (ie which should run for both Sprite & Text)
const genericCases: [
typeof SpriteRendering | typeof TextRendering,
SpriteRendering | TextRendering
][] = [
[SpriteRendering, new SpriteRendering(PIXI.Texture.WHITE)],
[TextRendering, new TextRendering('Test', 16, 0xffffff)],
];
describe('PixiRendering (Each Subtype)', () => {
for (const [componentClass, component] of genericCases) {
describe(componentClass.name, () => {
// Run tests for both SpriteRendering & TextRendering
beforeEach(() => {
mockEntity = new YaveEntity();
mockEntity.components.add(new Position(1, 2, 3), component);
});
describe('onEntityAdded', () => {
it('should automatically add the sprite to the rendering engine', () => {
component.addedToEngine = false;
pixiRenderer.onAddedEntities(mockEntity);
expect(
pixiRenderer.yaveEngine?.rendering.world?.addChild
).toBeCalled();
expect(
mockEntity.components.get<PixiRendering>(componentClass)
.addedToEngine
).toBe(true);
});
});
describe('processEntity', () => {
// When the entity already exists
it("should automatically add pre-existing entity's sprite to the rendering engine", () => {
const pixiRendering = mockEntity.components.get<PixiRendering>(
componentClass
);
component.addedToEngine = false;
(pixiRenderer as any).processEntity(mockEntity);
expect(
pixiRenderer.yaveEngine?.rendering.world?.addChild
).toBeCalled();
expect(pixiRendering.addedToEngine).toBe(true);
});
it("should update the sprite's position", () => {
const pixiRendering = mockEntity.components.get<PixiRendering>(
componentClass
);
(pixiRenderer as any).processEntity(mockEntity);
const pos = mockEntity.components.get(Position);
expect(pixiRendering.pixiObj.position.x).toBe(pos.x);
expect(pixiRendering.pixiObj.position.y).toBe(pos.y);
});
it("should update the sprite's rotation (when there is one)", () => {
const pixiRendering = mockEntity.components.get<PixiRendering>(
componentClass
);
mockEntity.components.add(new Rotation(45));
(pixiRenderer as any).processEntity(mockEntity);
const rot = mockEntity.components.get(Rotation);
expect(pixiRendering.pixiObj.angle).toBe(rot.z);
expect(pixiRendering.pixiObj.pivot.x).toBe(rot.pivot.x);
expect(pixiRendering.pixiObj.pivot.y).toBe(rot.pivot.y);
});
it("should update the sprite's scale (when there is one)", () => {
const pixiRendering = mockEntity.components.get<PixiRendering>(
componentClass
);
mockEntity.components.add(new Scale(1, 2));
(pixiRenderer as any).processEntity(mockEntity);
const scale = mockEntity.components.get(Scale);
expect(pixiRendering.pixiObj.scale.x).toBe(scale.x);
expect(pixiRendering.pixiObj.scale.y).toBe(scale.y);
});
});
});
}
});
describe('SpriteRendering', () => {
beforeEach(() => {
mockEntity = new YaveEntity();
mockEntity.components.add(new Position(1, 2, 3));
mockEntity.components.add(new SpriteRendering(PIXI.Texture.WHITE));
});
describe('processEntity', () => {
it("should update the sprite's color and alpha", () => {
(pixiRenderer as any).processEntity(mockEntity);
const sprite = mockEntity.components.get(SpriteRendering);
expect(sprite.sprite.alpha).toBe(sprite.alpha);
expect(sprite.sprite.tint).toBe(sprite.color);
});
});
});
// TODO: Should this be moved to another file
describe('TextRendering', () => {
beforeEach(() => {
mockEntity = new YaveEntity();
mockEntity.components.add(new Position(1, 2, 3));
mockEntity.components.add(new TextRendering('Test', 16, 0xffffff));
});
describe('processEntity', () => {
it("should update the sprite's text & style", () => {
(pixiRenderer as any).processEntity(mockEntity);
const textRendering = mockEntity.components.get(TextRendering);
expect(textRendering.textObject.text).toBe(textRendering.text);
expect(textRendering.textObject.style).toBe(textRendering.style);
});
});
});
});
|
Pandawan/yave
|
src/base/components/scale.spec.ts
|
import { Scale } from './scale';
import { Vector } from '../../utils';
describe('Scale Component', () => {
describe('constructor', () => {
it('should work with empty parameters', () => {
const scale = new Scale();
expect(scale.x).toBe(1);
expect(scale.y).toBe(1);
expect(scale.z).toBe(1);
});
it('should work with one parameter', () => {
const scale = new Scale(2);
expect(scale.x).toBe(2);
expect(scale.y).toBe(2);
expect(scale.z).toBe(2);
});
it('should work with two parameters', () => {
const scale = new Scale(2, 3);
expect(scale.x).toBe(2);
expect(scale.y).toBe(3);
expect(scale.z).toBe(1);
});
it('should work with three parameters', () => {
const scale = new Scale(2, 3, 4);
expect(scale.x).toBe(2);
expect(scale.y).toBe(3);
expect(scale.z).toBe(4);
});
it('should work with a vector parameter', () => {
const vec = new Vector(2, 3, 4);
const scale = new Scale(vec);
expect(scale.x).toBe(vec.x);
expect(scale.y).toBe(vec.y);
expect(scale.z).toBe(vec.z);
});
});
});
|
Pandawan/yave
|
src/rendering/components/pixiRendering.ts
|
<reponame>Pandawan/yave
import { Component } from '@trixt0r/ecs';
import PIXI from '@/lib/pixi';
export abstract class PixiRendering implements Component {
/**
* The underlying PIXI object.
*/
public abstract get pixiObj(): PIXI.Container;
/**
* The transparency of the object (from 0 to 1);
*/
public get alpha(): number {
return this.pixiObj.alpha;
}
public set alpha(value: number) {
this.pixiObj.alpha = value;
}
/**
* The width (in pixels) of the object.
*/
public get width(): number {
return this.pixiObj.width;
}
/**
* The height (in pixels) of the object.
*/
public get height(): number {
return this.pixiObj.width;
}
/**
* Whether or not the sprite has been added to the renderingEngine.
* (This prevents it from being added/rendered multiple times).
*/
public addedToEngine = false;
}
|
Pandawan/yave
|
src/extras/tilemap/index.ts
|
export * from './components/staticTilemap';
export * from './components/tilemapRendering';
export * from './systems/tilemapProcessor';
|
Pandawan/yave
|
src/ecs/entitySystem.ts
|
import {
ComponentClass,
Component,
AspectListener,
Aspect,
Engine,
} from '@trixt0r/ecs';
import { YaveSystem } from './system';
import { RunOptions } from './runOptions';
import { YaveEntity } from './entity';
type CompClass = ComponentClass<Component>;
/**
* ECS System which processes each entity with optional filtering.
*/
export abstract class YaveEntitySystem extends YaveSystem
implements AspectListener {
/**
* The optional aspect, if any.
*
* @protected
* @type {(Aspect | null)}
*/
protected aspect: Aspect | null = null;
/**
* Creates an instance of YaveEntitySystem.
*
* @param priority The priority of this system. The lower the value the earlier it will process.
* @param all Optional component types which should all match.
* @param exclude Optional component types which should not match.
* @param one Optional component types of which at least one should match.
*/
constructor(
public priority: number = 0,
protected all?: CompClass[],
protected exclude?: CompClass[],
protected one?: CompClass[]
) {
super(priority);
}
/** @inheritdoc */
onAddedToEngine(engine: Engine): void {
this.aspect = Aspect.for(engine, this.all, this.exclude, this.one);
this.aspect.addListener(this);
}
/** @inheritdoc */
onRemovedFromEngine(): void {
if (this.aspect === null || this.aspect === undefined) return;
this.aspect.removeListener(this);
this.aspect.detach();
}
/**
* Called if new entities got added to the system.
*
* @param entities
*/
onAddedEntities?(...entities: YaveEntity[]): void;
/**
* Called if existing entities got removed from the system.
*
* @param entities
*/
onRemovedEntities?(...entities: YaveEntity[]): void;
/**
* Called if the entities got cleared.
*/
onClearedEntities?(): void;
/**
* Called if the entities got sorted.
*/
onSortedEntities?(): void;
/**
* Gets called if new components got added to the given entity.
*
* @param entity
* @param components
*/
onAddedComponents?(entity: YaveEntity, ...components: Component[]): void;
/**
* Gets called if components got removed from the given entity.
*
* @param entity
* @param components
*/
onRemovedComponents?(entity: YaveEntity, ...components: Component[]): void;
/**
* Gets called if the components of the given entity got cleared.
*
* @param entity
*/
onClearedComponents?(entity: YaveEntity): void;
/**
* Gets called if the components of the given entity got sorted.
*
* @param entity
*/
onSortedComponents?(entity: YaveEntity): void;
/** @inheritdoc */
process(options?: RunOptions): void {
if (this._engine === null || this._engine === undefined) return;
const entities =
this.aspect !== null && this.aspect !== undefined
? this.aspect.entities
: this._engine.entities.elements;
// Extra render system failcheck (just in case)
if (options !== undefined && options.isRendering !== this.isRenderSystem)
return;
for (let i = 0, l = entities.length; i < l; i++) {
this.processEntity(
entities[i] as YaveEntity,
options,
i,
entities as YaveEntity[]
);
}
}
/**
* Processes the given entity.
*
* @abstract
* @param entity The current entity being processed
* @param options The options passed to the system from ECS.
* @param index The index of that entity in the entities list.
* @param entities The list of entities from which the entity was taken.
*/
abstract processEntity(
entity: YaveEntity,
options?: RunOptions,
index?: number,
entities?: YaveEntity[]
): void;
}
/**
* ECS Rendering System which processes each entity with an optional filtering.
*/
export abstract class YaveEntityRenderingSystem extends YaveEntitySystem {
/** @inheritdoc */
public readonly isRenderSystem = true;
}
|
Pandawan/yave
|
src/base/components/rotation.ts
|
<reponame>Pandawan/yave<gh_stars>1-10
import { Component } from '@trixt0r/ecs';
import { normalize, Vector } from '../../utils';
/**
* Rotation Component to represent an entity's rotation in world space.
*/
export class Rotation extends Vector implements Component {
/**
* Rotation on the x axis (in degrees).
*/
public declare x: number;
/**
* Rotation on the y axis (in degrees).
*/
public declare y: number;
/**
* Rotation on the z axis (in degrees).
*/
public declare z: number;
/**
* Pivot point to rotate around.
*/
public pivot: Vector;
/**
* Access the rotation values in radians.
* NOTE: Internally, all values are stored in degrees.
*/
public get radians(): {
// For some reason TS requires the docs here instead of on the object itself
/**
* Rotation on the x axis (in radians).
*/
x: number;
/**
* Rotation on the y axis (in radians).
*/
y: number;
/**
* Rotation on the x axis (in radians).
*/
z: number;
} {
// Need to alias this because the {} object has its own this value
/* eslint-disable-next-line @typescript-eslint/no-this-alias */
const rotThis = this;
return {
/**
* Rotation on the x axis (in radians).
*/
get x(): number {
return (rotThis.x * Math.PI) / 180;
},
set x(value: number) {
const clampedValue = normalize(value, 0, 2 * Math.PI);
rotThis.x = (clampedValue * 180) / Math.PI;
},
/**
* Rotation on the y axis (in radians).
*/
get y(): number {
return (rotThis.y * Math.PI) / 180;
},
set y(value: number) {
const clampedValue = normalize(value, 0, 2 * Math.PI);
rotThis.y = (clampedValue * 180) / Math.PI;
},
/**
* Rotation on the x axis (in radians).
*/
get z(): number {
return (rotThis.z * Math.PI) / 180;
},
set z(value: number) {
const clampedValue = normalize(value, 0, 2 * Math.PI);
rotThis.z = (clampedValue * 180) / Math.PI;
},
};
}
/**
* Create a rotation component with default values of 0.
*/
constructor();
/**
* Create a 2D rotation component with one rotation angle.
* @param angle Rotation on the z axis (in degrees).
*/
constructor(angle: number);
/**
* Create a 3D rotation component.
* @param x Rotation on the x axis (in degrees).
* @param y Rotation on the y axis (in degrees).
* @param z Rotation on the z axis (in degrees).
*/
constructor(x: number, y: number, z: number);
/**
* Create a rotation component from the given vector.
* @param vector Rotation vector (in degrees).
*/
constructor(vector: Vector);
constructor(x?: number | Vector, y?: number, z?: number) {
// If a vector is passed, reassign x, y, z to the vector values
if (x instanceof Vector) {
const vec = x;
x = vec.x;
z = vec.z;
y = vec.y;
}
// If only one rotation is passed, assume this is a 2D rotation (aka rotation around Z axis)
if (x !== undefined && y === undefined && z === undefined) {
super(0, 0, normalize(x, 0, 360));
}
// Otherwise, just use the passed parameters
// this allows edge cases like Rotation(undefined, 0, 0) to work.
else {
super(
normalize(x ?? 0, 0, 360),
normalize(y ?? 0, 0, 360),
normalize(z ?? 0, 0, 360)
);
}
// Set default pivot point in the middle
this.pivot = new Vector(0, 0, 0);
}
public set(angle: number): Rotation;
public set(x: number, y: number, z: number): Rotation;
public set(x: number, y?: number, z?: number): Rotation {
if (x !== undefined && y === undefined && z === undefined) {
this.x = 0;
this.y = 0;
this.z = normalize(x ?? 0, 0, 360);
} else {
this.x = normalize(x ?? 0, 0, 360);
this.y = normalize(y ?? 0, 0, 360);
this.z = normalize(z ?? 0, 0, 360);
}
return this;
}
public add(other: Rotation): Rotation {
this.x += normalize(other.x ?? 0, 0, 360);
this.y += normalize(other.y ?? 0, 0, 360);
this.z += normalize(other.z ?? 0, 0, 360);
return this;
}
/**
* Create a 2D rotation component with one rotation angle.
* NOTE: Converting from radians to degrees might result in floating point errors.
* @param angle Rotation on the z axis (in radians).
*/
public static fromRadians(angle: number): Rotation;
/**
* Create a Rotation component from the given radian values.
*
* NOTE: Converting from radians to degrees might result in floating point errors.
* @param x Rotation on the x axis (in radians).
* @param y Rotation on the y axis (in radians).
* @param z Rotation on the z axis (in radians).
*/
public static fromRadians(x: number, y: number, z: number): Rotation;
/**
* Create a rotation component from the given vector.
* NOTE: Converting from radians to degrees might result in floating point errors.
* @param vector Rotation vector (in radians).
*/
public static fromRadians(vector: Vector): Rotation;
public static fromRadians(
x: number | Vector,
y?: number,
z?: number
): Rotation {
// If a vector is passed, reassign x, y, z to the vector values
if (x instanceof Vector) {
const vec = x;
x = vec.x;
z = vec.z;
y = vec.y;
}
const clampedX = normalize(x, 0, 2 * Math.PI);
const clampedY = y !== undefined ? normalize(y, 0, 2 * Math.PI) : undefined;
const clampedZ = z !== undefined ? normalize(z, 0, 2 * Math.PI) : undefined;
if (clampedY === undefined && clampedZ === undefined) {
return new Rotation((clampedX * 180) / Math.PI);
}
return new Rotation(
(clampedX * 180) / Math.PI,
((clampedY ?? 0) * 180) / Math.PI,
((clampedZ ?? 0) * 180) / Math.PI
);
}
}
|
Pandawan/yave
|
src/extras/tilemap/components/dynamicTilemap.ts
|
/**
* TODO: Dynamic Tilemap (later when I have time)
*
* This is a tilemap similar to StaticTilemap, but instead of mapping position to TileDefinition,
* it maps position to entityId. Each tile is an entity but is rendered through the TilemapProcessor like with a StaticTilemap.
*
* The tileEntities have a "Tile" component with which texture to render.
* This allows for tileEntities to have custom components and therefore custom logic.
*
* The TilemapProcessor would work the same way, looping over the tiles references in the DynamicTilemap's Map<position, id>.
* This means that any tile that is not referenced in a DynamicTilemap isn't rendered.
*/
|
Pandawan/yave
|
src/ecs/ecs.ts
|
import { Engine, EngineMode, SystemMode, System } from '@trixt0r/ecs';
import { RunOptions } from './runOptions';
import { YaveEngine } from '@/engine';
import { YaveSystem } from './system';
export class YaveECS extends Engine {
/**
* Reference to the actual yave engine that uses this ECS engine.
*/
public readonly yaveEngine: YaveEngine;
/** @inheritdoc */
constructor(engine: YaveEngine) {
super();
this.yaveEngine = engine;
}
/**
* Updates all systems in this engine with the given options.
*
* @param {RunOptions} options
* @param {EngineMode} [mode = EngineMode.DEFAULT]
* @returns {void | Promise<void>}
*/
run(
// Overriding run with an interface "RunOptions" so that isRenderSystem can work (also make it required)
options: RunOptions,
mode: EngineMode = EngineMode.DEFAULT
): void | Promise<void> {
return this[mode](options);
}
/**
* Updates all systems in this engine with the given options,
* without waiting for a resolve or reject of each system.
*
* @param {RunOptions} [options]
* @returns {void}
*/
protected runDefault(options?: RunOptions): void {
const length = this._activeSystems.length;
for (let i = 0; i < length; i++) {
if (this.shouldRunSystem(this._activeSystems[i], options)) {
this._activeSystems[i].run(options, SystemMode.SYNC);
}
}
}
/**
* Updates all systems in this engine with the given options,
* by waiting for a system to resolve or reject before continuing with the next one.
*
* @param {RunOptions} [options]
* @returns {Promise<void>}
*/
protected async runSuccessive(options?: RunOptions): Promise<void> {
const length = this._activeSystems.length;
for (let i = 0; i < length; i++)
if (this.shouldRunSystem(this._activeSystems[i], options)) {
await this._activeSystems[i].run(options, SystemMode.SYNC);
}
}
/**
* Updates all systems in this engine with the given options,
* by running all systems in parallel and waiting for all systems to resolve or reject.
*
* @param {RunOptions} [options]
* @returns {Promise<void>}
*/
protected async runParallel(options?: RunOptions): Promise<void> {
const mapped = this._activeSystems.map(system => {
if (this.shouldRunSystem(system, options)) {
return system.run(options, SystemMode.ASYNC);
}
});
await Promise.all(mapped);
}
/**
* Checks whether or not the given system should run when passed the given options.
* @param system The system to check for.
* @param options The options to pass.
*/
protected shouldRunSystem(system: System, options?: RunOptions): boolean {
const isRendering: boolean | undefined = options?.isRendering;
const isRenderSystem: boolean | undefined = (system as YaveSystem)
.isRenderSystem;
// TODO: Maybe I should just keep track of renderSystems and systems as two separate arrays so I don't have to check every frame
// Runs systems according to render system requirements
// If either is undefined, it will act as if it was not rendering/not a render system
return (
(isRendering === true && isRenderSystem === true) ||
(isRendering !== true && isRenderSystem !== true)
);
}
}
|
Pandawan/yave
|
src/rendering/components/spriteRendering.ts
|
import PIXI from '@/lib/pixi';
import { PixiRendering } from './pixiRendering';
// NOTE: This is named SpriteRendering because "Sprite" name conflicts with pixi.js' Sprite and might be too confusing
export class SpriteRendering extends PixiRendering {
/**
* The PIXI.Sprite object.
*/
public sprite: PIXI.Sprite;
/**
* The color (in hex) to apply to the sprite.
* Note: default is 0xffffff (white)
*/
public get color(): number {
return this.sprite.tint;
}
public set color(value: number) {
this.sprite.tint = value;
}
/**
* The origin position of the texture (between 0 and 1).
* Note: This is different from pivot point.
*/
public get anchor(): PIXI.ObservablePoint {
return this.sprite.anchor;
}
public set anchor(value: PIXI.ObservablePoint) {
this.sprite.anchor = value;
}
/**
* The underlying generic PIXI object.
*/
public get pixiObj(): PIXI.Container {
return this.sprite;
}
constructor(textureURL: string, color?: number, alpha?: number);
constructor(texture: PIXI.Texture, color?: number, alpha?: number);
constructor(sprite: PIXI.Sprite, color?: number, alpha?: number);
constructor(
sprite: string | PIXI.Sprite | PIXI.Texture,
color = 0xffffff,
alpha = 1
) {
super();
if (sprite instanceof PIXI.Sprite) {
this.sprite = sprite;
} else {
this.sprite = PIXI.Sprite.from(sprite);
}
this.color = color;
this.alpha = alpha;
this.anchor.set(0.5, 0.5);
}
}
|
Pandawan/yave
|
src/ecs/runOptions.ts
|
<reponame>Pandawan/yave
/**
* The options to pass to the ECS's run method
*/
export interface RunOptions {
/**
* Change in time since last update/frame (in ms).
*/
deltaTime: number;
/**
* Whether or not this execution happens on a "render" or "update" tick
*/
isRendering: boolean;
}
|
Pandawan/yave
|
src/rendering/systems/cameraRenderer.spec.ts
|
<filename>src/rendering/systems/cameraRenderer.spec.ts
import { YaveEntity } from '@/ecs/entity';
import { Position, Rotation } from '@/base';
import { CameraRenderer } from './cameraRenderer';
import { Camera } from '../components/camera';
describe('CameraRenderer', () => {
let mockActiveCameraEntity: YaveEntity;
let mockInactiveCameraEntity: YaveEntity;
let cameraRenderer: CameraRenderer;
beforeEach(() => {
document.body.innerHTML = '<div id="game"></div>';
mockActiveCameraEntity = new YaveEntity();
mockActiveCameraEntity.components.add(
new Position(1, 2, 3),
new Rotation(45),
new Camera(true)
);
mockInactiveCameraEntity = new YaveEntity();
mockInactiveCameraEntity.components.add(
new Position(1, 2, 3),
new Rotation(45),
new Camera(false)
);
cameraRenderer = new CameraRenderer();
(cameraRenderer as any)._yaveEngine = {
ecs: {
entities: [mockActiveCameraEntity, mockInactiveCameraEntity],
},
rendering: {
world: {
addChild: jest.fn(),
moveCenter: jest.fn(),
zIndex: 0,
angle: 0,
pivot: {
set: jest.fn(),
},
},
},
};
});
describe('choosing camera', () => {
beforeEach(() => {
(cameraRenderer as any)._engine = {};
});
it('should only process the active camera', () => {
(cameraRenderer as any).aspect = {
entities: cameraRenderer.yaveEngine?.ecs.entities,
};
(cameraRenderer as any).processEntity = jest.fn();
cameraRenderer.process();
// Make sure it called the active camera
expect(cameraRenderer.processEntity).toBeCalledWith(
mockActiveCameraEntity
);
// Make sure only one camera is processed
expect(cameraRenderer.processEntity).toBeCalledTimes(1);
});
it('should throw when there are more than one active cameras', () => {
mockInactiveCameraEntity.components.get(Camera).active = true;
(cameraRenderer as any).aspect = {
entities: [mockActiveCameraEntity, mockInactiveCameraEntity],
};
expect(() => cameraRenderer.process()).toThrow();
});
});
it("should update the viewport/world's position and zIndex", () => {
cameraRenderer.processEntity(mockActiveCameraEntity);
const pos = mockActiveCameraEntity.components.get(Position);
const world = cameraRenderer.yaveEngine?.rendering.world;
expect(world?.moveCenter).toBeCalledWith(pos.x, pos.y);
expect(world?.zIndex).toBe(pos.z);
});
it("should update the viewport/world's rotation and pivot", () => {
cameraRenderer.processEntity(mockActiveCameraEntity);
const rot = mockActiveCameraEntity.components.get(Rotation);
const world = cameraRenderer.yaveEngine?.rendering.world;
expect(world?.angle).toBe(rot.z);
expect(world?.pivot.set).toBeCalledWith(rot.pivot.x, rot.pivot.y);
});
describe('follow entity', () => {
it("should update the position component with the entity to follow's position", () => {
mockActiveCameraEntity.components.get(Camera).followEntity =
mockInactiveCameraEntity.id;
const pos = mockActiveCameraEntity.components.get(Position);
(pos as any).set = jest.fn();
const targetPos = mockInactiveCameraEntity.components.get(Position);
cameraRenderer.processEntity(mockActiveCameraEntity);
expect(pos.set).toBeCalledWith(targetPos.x, targetPos.y, pos.z);
});
it('should throw if the entity to follow does not exist', () => {
mockActiveCameraEntity.components.get(Camera).followEntity =
'IMPOSSIBLE ID';
expect(() =>
cameraRenderer.processEntity(mockActiveCameraEntity)
).toThrow();
});
it('should throw if the entity to follow does not have a position component', () => {
mockActiveCameraEntity.components.get(Camera).followEntity =
mockInactiveCameraEntity.id;
// Remove position component
mockInactiveCameraEntity.components.remove(
mockInactiveCameraEntity.components.get(Position)
);
expect(() =>
cameraRenderer.processEntity(mockActiveCameraEntity)
).toThrow();
});
});
});
|
Pandawan/yave
|
src/utils/math.spec.ts
|
import { normalize } from './math';
describe('Math Utils', () => {
describe('normalize', () => {
it("shouldn't change value between range", () => {
expect(normalize(5, 0, 10)).toBe(5);
});
it('should wrap a large value to start correctly', () => {
expect(normalize(12, 0, 10)).toBe(2);
});
it('should wrap a small value to end correctly', () => {
expect(normalize(-2, 0, 10)).toBe(8);
});
it('should still work with values that are more than twice the range away', () => {
expect(normalize(52, 0, 10)).toBe(2);
});
});
});
|
Pandawan/yave
|
src/rendering/systems/framerateCounter.ts
|
<filename>src/rendering/systems/framerateCounter.ts
import { RunOptions, YaveRenderingSystem } from '@/ecs';
// TODO: Spec.ts
export class FramerateCounter extends YaveRenderingSystem {
private _textElement: HTMLElement;
constructor() {
super();
this._textElement = document.createElement('span');
this._textElement.style.position = 'absolute';
this._textElement.style.top = '0';
this._textElement.style.right = '0';
this._textElement.style.padding = '0.5rem';
this._textElement.style.color = 'white';
this._textElement.style.background = 'rgba(0,0,0,0.25)';
this._textElement.style.fontFamily = 'sans-serif';
this._textElement.style.userSelect = 'none';
document.body.appendChild(this._textElement);
}
process(options?: RunOptions): void {
// TODO: Clean this up so that I don't need all of these in every single system that overrides process
if (this._engine === null || this._engine === undefined) return;
// Need deltaTime
if (options === undefined) return;
this._textElement.textContent = `FPS ${Math.round(
(1 / options.deltaTime) * 1000
)}`;
}
}
|
Pandawan/yave
|
src/ecs/system.spec.ts
|
<filename>src/ecs/system.spec.ts
import { YaveSystem, YaveRenderingSystem } from './system';
describe('YaveSystem', () => {
class TestSystem extends YaveSystem {
process = jest.fn();
}
let system: TestSystem;
beforeEach(() => {
system = new TestSystem();
});
describe('initial', () => {
it('should have a null engine property', () => {
expect(system.engine).toBeNull();
});
it('should have a null yaveEngine property', () => {
expect(system.yaveEngine).toBeNull();
});
it('should have isRenderSystem set to false', () => {
expect(system.isRenderSystem).toBe(false);
});
});
});
describe('YaveRenderingSystem', () => {
class TestRenderingSystem extends YaveRenderingSystem {
process = jest.fn();
}
let system: TestRenderingSystem;
beforeEach(() => (system = new TestRenderingSystem()));
describe('initial', () => {
it('should have isRenderSystem set to true', () => {
expect(system.isRenderSystem).toBe(true);
});
});
});
|
Pandawan/yave
|
src/utils/math.ts
|
<gh_stars>1-10
/**
* Normalizes any number to a given range
* by assuming the range wraps around when going below min or above max.
*
* NOTE: This is especially useful to wrap around angles (in rads or degs).
* @param value The value to normalize.
* @param start The start boundary.
* @param end The end boundary.
*/
export function normalize(value: number, start: number, end: number): number {
const width: number = end - start; //
const offsetValue: number = value - start; // value relative to 0
// Add start to reset back to start of original range
return offsetValue - Math.floor(offsetValue / width) * width + start;
}
|
Pandawan/yave
|
src/extras/tilemap/components/staticTilemap.ts
|
<filename>src/extras/tilemap/components/staticTilemap.ts
import { Component } from '@trixt0r/ecs';
import { Vector } from '@/utils';
// TODO: Spec file
/**
* Creates a static tilemap where each tile is just an ID for a definition.
* This component keeps track of a definition of tiles.
* It represents the map as a 2D array of references to a corresponding tile definition.
*/
export class StaticTilemap<TileId = string> implements Component {
/**
* 2D Map of internal tile IDs as references to the definitions.
* Key is position, Value is tile ID.
*/
private _tiles: Map<string, TileId>;
/**
* 2D Array of [position, tileId] that have been modified.
* Key is position, Value is tile ID.
* (Clear this with clearDirty).
*/
private _dirtyTiles: Map<string, TileId | null>;
/**
* 2D Map of internal tile IDs as references to the definitions.
* Key is position, Value is tile ID.
* (Use associated functions to modify tiles).
*/
public get tiles(): ReadonlyMap<string, TileId> {
return this._tiles;
}
/**
* 2D Map of tile positions that have been modified in the last update.
* Key is position, Value is tile ID (null for "removed").
* (Clear this with clearDirty).
*/
public get dirtyTiles(): ReadonlyMap<string, TileId | null> {
return this._dirtyTiles;
}
/**
* Whether or not the tilemap has been modified in the last update.
*/
public get isDirty(): boolean {
return this._dirtyTiles.size > 0;
}
public constructor() {
this._tiles = new Map();
this._dirtyTiles = new Map();
}
// #region Tile Access
// TODO: Support z position (multiple layers? idk)
public getTileAt(position: Vector): TileId | undefined {
return this._tiles.get(position.toString(true));
}
public setTileAt(position: Vector, tileId: TileId | null): void {
const posStr = position.toString(true);
// If tileId is undefined, it has been removed
if (tileId === null) {
this._tiles.delete(posStr);
this._dirtyTiles.set(posStr, null);
return;
}
// Set tile & add to list of dirty
this._tiles.set(posStr, tileId);
this._dirtyTiles.set(posStr, tileId);
}
public removeTileAt(position: Vector): void {
this.setTileAt(position, null);
}
// #endregion
/**
* Clear the list of dirty tiles (usually after rendering/processing).
*/
public clearDirty(): void {
this._dirtyTiles.clear();
}
}
|
Pandawan/yave
|
src/extras/tilemap/components/tilemapRendering.ts
|
<reponame>Pandawan/yave
import PIXI from '@/lib/pixi';
import { PixiRendering } from '@/rendering/components/pixiRendering';
import { Vector } from '@/utils';
type TileDefinition = PIXI.Texture | string;
export class TilemapRendering<TileId = string> extends PixiRendering {
/**
* Definition of each tile.
* Key is tile ID, Value is tile definition.
*/
public tileDefinitions: Map<TileId, TileDefinition>;
/**
* The actual PIXI.tilemap object.
*/
public tileLayer: PIXI.tilemap.CompositeRectTileLayer;
/**
* Size to render tiles as (in pixels).
*/
public tileSize: number;
/**
* The underlying generic PIXI object.
*/
public get pixiObj(): PIXI.Container {
return this.tileLayer;
}
constructor(tileSize = 32, textures?: PIXI.Texture[]) {
super();
this.tileDefinitions = new Map();
this.tileLayer = new PIXI.tilemap.CompositeRectTileLayer(0, textures);
this.tileSize = tileSize;
}
// #region Position Utilities
/**
* Converts the given world position to a tilemap position.
* @param worldPosition A position in world coordinates.
*/
public worldToTilemapPosition(worldPosition: Vector): Vector {
// TODO: Spec
const tilemapPosition = worldPosition
.clone()
.map(v => v / this.tileSize)
.floor();
// Don't want to affect z
tilemapPosition.z = worldPosition.z;
return tilemapPosition;
}
/**
* Converts the given tilemap position to a world position.
* @param tilemapPosition A position in tilemap coordinates.
* @param offset An vector of values between 0 and 1 to specify
* the offset of the final position from the corner.
*/
public tilemapToWorldPosition(
tilemapPosition: Vector,
offset = new Vector(0, 0)
): Vector {
// TODO: Spec
return tilemapPosition
.clone()
.map(v => v * this.tileSize)
.add(offset.map(v => v * this.tileSize));
}
// #endregion
}
|
Pandawan/yave
|
src/utils/vector.ts
|
<filename>src/utils/vector.ts<gh_stars>1-10
/**
* Represents a position, direction, rotation, etc. (can be used for 2D and 3D coordinates).,
*/
export class Vector {
public x: number;
public y: number;
public z: number;
/**
* Create a Vector with default values of 0
*/
constructor();
/**
* Create a 2D Vector (with x and y).
*/
constructor(x: number, y: number);
/**
* Create a 3D Vector (with x, y, and z).
*/
constructor(x: number, y: number, z: number);
constructor(x = 0, y = 0, z = 0) {
this.x = x ?? 0;
this.y = y ?? 0;
this.z = z ?? 0;
}
public set(x: number, y: number, z = 0): Vector {
this.x = x;
this.y = y;
this.z = z;
return this;
}
public add(other: Vector): Vector {
// TODO: Spec
this.x += other.x;
this.y += other.y;
this.z += other.z;
return this;
}
public map(
callbackfn: (value: number, index: number, vector: Vector) => number
): Vector {
this.x = callbackfn(this.x, 0, this);
this.y = callbackfn(this.y, 1, this);
this.z = callbackfn(this.z, 2, this);
return this;
}
public round(): Vector {
this.x = Math.round(this.x);
this.y = Math.round(this.y);
this.z = Math.round(this.z);
return this;
}
public floor(): Vector {
this.x = Math.floor(this.x);
this.y = Math.floor(this.y);
this.z = Math.floor(this.z);
return this;
}
public ceil(): Vector {
this.x = Math.ceil(this.x);
this.y = Math.ceil(this.y);
this.z = Math.ceil(this.z);
return this;
}
public clone(): Vector {
return new Vector(this.x, this.y, this.z);
}
/**
* Convert the given vector to a 3-element array with [x, y, z].
* @param as2D Whether or not to only request for the x and y component of the vector.
*/
public toArray(as2D?: false): [number, number, number];
/**
* Convert the given vector to a 2-element array with [x, y].
* @param as2D Whether or not to only request for the x and y component of the vector.
*/
public toArray(as2D: true): [number, number];
public toArray(as2D = false): [number, number] | [number, number, number] {
return as2D ? [this.x, this.y] : [this.x, this.y, this.z];
}
/**
* Convert the given vector to a string (x, y, z).
* @param as2D Whether or not to only request for the x and y component of the vector.
*/
public toString(as2D?: false): string;
/**
* Convert the given vector to a string (x, y).
* @param as2D Whether or not to only request for the x and y component of the vector.
*/
public toString(as2D: true): string;
public toString(as2D = false): string {
return as2D
? `(${this.x}, ${this.y})`
: `(${this.x}, ${this.y}, ${this.z})`;
}
public static fromString(value: string): Vector {
const match = value.match(
/\( *(?:(-?[0-9.]+) *,)? *(?:(-?[0-9.]+) *,)? *(?:(-?[0-9.]+)) *\)/
);
if (match === undefined || match === null || match.length === 0) {
throw new Error('Passed string could not be parsed as vector.');
}
// Take the match (array of strings) and convert it to an array of numbers
const pos = match
.slice(1, 4)
.filter(val => val !== undefined && val !== null)
.map(val => new Number(val).valueOf());
return new this(pos?.[0] ?? 0, pos?.[1] ?? 0, pos?.[2] ?? 0);
}
}
|
Pandawan/yave
|
src/base/components/rotation.spec.ts
|
<reponame>Pandawan/yave
import { Rotation } from './rotation';
import { Vector } from '../../utils';
describe('Rotation Component', () => {
describe('constructor', () => {
it('should set default values when used with empty parameters', () => {
const rot = new Rotation();
expect(rot.x).toBe(0);
expect(rot.y).toBe(0);
expect(rot.z).toBe(0);
});
it('should set z when used with one parameter', () => {
const rot = new Rotation(1);
expect(rot.x).toBe(0);
expect(rot.y).toBe(0);
expect(rot.z).toBe(1);
});
it('should set x, y, and z when used with three parameters', () => {
const rot = new Rotation(1, 2, 3);
expect(rot.x).toBe(1);
expect(rot.y).toBe(2);
expect(rot.z).toBe(3);
});
it('should set x, y, and z when used with a vector parameter', () => {
const vec = new Vector(1, 2, 3);
const rot = new Rotation(vec);
expect(rot.x).toBe(vec.x);
expect(rot.y).toBe(vec.y);
expect(rot.z).toBe(vec.z);
});
it('should clamp values correctly between 0 and 360', () => {
const rot = new Rotation(-30, 405, 780);
expect(rot.x).toBe(330); // Under range
expect(rot.y).toBe(45); // Above range
expect(rot.z).toBe(60); // More than one revolution
});
it('should set the pivot point to the center by default', () => {
const rot = new Rotation();
expect(rot.pivot.x).toBe(0);
expect(rot.pivot.y).toBe(0);
expect(rot.pivot.z).toBe(0);
});
});
describe('fromRadians', () => {
it('should set z when used with one parameter', () => {
const rot = Rotation.fromRadians(Math.PI / 4);
expect(rot.x).toBeCloseTo(0);
expect(rot.y).toBeCloseTo(0);
expect(rot.z).toBeCloseTo(45); // pi/4 rad = 45deg
});
it('should set x, y, and z when used with three parameters', () => {
const rot = Rotation.fromRadians(Math.PI / 6, Math.PI / 4, Math.PI / 3);
expect(rot.x).toBeCloseTo(30);
expect(rot.y).toBeCloseTo(45);
expect(rot.z).toBeCloseTo(60);
});
it('should clamp values correctly between 0 and 2PI', () => {
const rot = Rotation.fromRadians(
-Math.PI / 6,
(Math.PI * 9) / 4,
(Math.PI * 13) / 3
);
expect(rot.x).toBeCloseTo(330); // Under range
expect(rot.y).toBeCloseTo(45); // Above range
expect(rot.z).toBeCloseTo(60); // More than one revolution
});
it('should set x, y, and z when used with a vector parameter', () => {
const vec = new Vector(Math.PI / 6, Math.PI / 4, Math.PI / 3);
const rot = Rotation.fromRadians(vec);
expect(rot.x).toBeCloseTo(30);
expect(rot.y).toBeCloseTo(45);
expect(rot.z).toBeCloseTo(60);
});
});
describe('radians', () => {
it('should return a radian value', () => {
const rot = new Rotation(30, 45, 60);
expect(rot.radians.x).toBeCloseTo(Math.PI / 6);
expect(rot.radians.y).toBeCloseTo(Math.PI / 4);
expect(rot.radians.z).toBeCloseTo(Math.PI / 3);
});
it('should convert radian values to degrees', () => {
const rot = new Rotation();
rot.radians.x = Math.PI / 6;
rot.radians.y = Math.PI / 4;
rot.radians.z = Math.PI / 3;
expect(rot.x).toBeCloseTo(30);
expect(rot.y).toBeCloseTo(45);
expect(rot.z).toBeCloseTo(60);
});
});
});
|
Pandawan/yave
|
src/base/index.ts
|
export * from './components/position';
export * from './components/rotation';
export * from './components/scale';
|
Pandawan/yave
|
src/extras/tilemap/systems/tilemapProcessor.ts
|
import { YaveEntity, YaveEntityRenderingSystem } from '@/ecs';
import { StaticTilemap } from '../components/staticTilemap';
import { TilemapRendering } from '../components/tilemapRendering';
import { Vector } from '@/utils';
/**
* Processes tilemaps to be rendered by the TilemapRendering engine.
* NOTE: This does not do any camera bound checking rendering optimization. (TODO: Maybe later)
*/
export class TilemapProcessor extends YaveEntityRenderingSystem {
// TODO: Spec file
constructor() {
super(undefined, [TilemapRendering], undefined, [StaticTilemap]);
}
processEntity(entity: YaveEntity): void {
if (
this.yaveEngine === null ||
this.yaveEngine.rendering.renderingEngine === null
)
return;
const tilemap = entity.components.get(StaticTilemap);
const rendering = entity.components.get(TilemapRendering);
if (tilemap.isDirty === false) return;
/*
* NOTE: This might seem inefficient but it is recommended by pixi-tilemap creator
* https://github.com/pixijs/pixi-tilemap/issues/14
*/
// Clear the entire tilemap before rendering cycle
rendering.tileLayer.clear();
// Loop through every tile and add it to be rendered
for (const [strPos, tileId] of tilemap.tiles) {
// TODO: This is very inefficient, string -> Vector b/c can't map over Vector
const tilePos = Vector.fromString(strPos);
const tileDef = rendering.tileDefinitions.get(tileId);
if (
tileId === undefined ||
tilePos === undefined ||
tileDef === undefined
) {
break;
}
rendering.tileLayer.addResizeableFrame(
tileDef,
tilePos.x * rendering.tileSize,
tilePos.y * rendering.tileSize,
// Auto-resize using UV so texture ALWAYS fills the full size
rendering.tileSize,
rendering.tileSize
);
}
tilemap.clearDirty();
}
}
|
Pandawan/yave
|
src/rendering/renderingEngine.spec.ts
|
import { AbstractRendering } from './renderingEngine';
describe('AbstractRendering', () => {
class MockRendering extends AbstractRendering<{}> {
init = jest.fn();
load = jest.fn();
render = jest.fn();
screenToWorldPosition = jest.fn();
worldToScreenPosition = jest.fn();
}
describe('constructor', () => {
it('should work when the container exists', () => {
document.body.innerHTML = '<div id="DOES_EXIST"></div>';
expect(() => new MockRendering('DOES_EXIST')).not.toThrow();
});
it('should error when the container does not exist', () => {
expect(() => new MockRendering('DOES_NOT_EXIST')).toThrow();
});
});
});
|
Pandawan/yave
|
src/ecs/entity.ts
|
<filename>src/ecs/entity.ts
import { AbstractEntity } from '@trixt0r/ecs';
import uuidv4 from 'uuid/v4';
/**
* Simple wrapper over Entity with pre-set UUID
*/
export class YaveEntity extends AbstractEntity {
constructor() {
super(uuidv4());
}
}
|
Pandawan/yave
|
src/lib/pixi.ts
|
<reponame>Pandawan/yave<gh_stars>1-10
// See: https://github.com/pixijs/pixi.js/issues/6227
import PIXI = require('pixi.js'); // TODO: Perhaps use @pixi/packages instead
window.PIXI = PIXI;
// Tilemap
import 'pixi-tilemap';
// Patch the tilemap with slightly modified functions for easier API usage
import './tilemapPatch';
export { Viewport } from 'pixi-viewport';
export default PIXI;
|
Pandawan/yave
|
src/rendering/systems/cameraRenderer.ts
|
import { YaveEntityRenderingSystem, YaveEntity } from '@/ecs';
import { Position, Rotation } from '@/base';
import { Camera } from '../components/camera';
/**
* Rendering System for SpriteRendering and TextRendering component.
*/
export class CameraRenderer extends YaveEntityRenderingSystem {
constructor() {
super(undefined, [Camera, Position], undefined);
}
process(): void {
if (this._engine === null || this._engine === undefined) return;
const entities = (this.aspect !== null && this.aspect !== undefined
? this.aspect.entities
: this._engine.entities.elements) as YaveEntity[];
// Only keep track of active cameras
const activeCameraEntities = entities.filter(
entity => entity.components.get(Camera).active === true
);
if (activeCameraEntities.length > 1)
throw new Error('Cannot have more than one active camera');
// If there are no cameras, just don't do anything
if (activeCameraEntities.length === 0) return;
this.processEntity(activeCameraEntities[0]);
}
processEntity(entity: YaveEntity): void {
if (
this.yaveEngine === null ||
this.yaveEngine.rendering.renderingEngine === null
)
return;
const camera = entity.components.get(Camera);
const position = entity.components.get(Position);
const rotation = entity.components.get(Rotation) as Rotation | undefined;
const world = this.yaveEngine.rendering.world;
// If there's no world/viewport, we don't care
if (world === null || world === undefined) return;
// TODO: Maybe follow entity should be a separate system from camera?
// TODO: Also viewport has a follow property to follow a PixiObject, is that worth it? (probs not)
// If have an entity to follow, set camera's position to that
if (camera.followEntity !== null) {
// Get the entity with followEntity ID
const entityToFollow = this.yaveEngine.ecs.entities
.filter(
(entity: YaveEntity | undefined) => entity?.id === camera.followEntity
)
.shift();
if (entityToFollow === undefined || entityToFollow === null) {
throw new Error(
`Could not find entity with ID ${camera.followEntity}.`
);
}
const entityToFollowPosition = entityToFollow.components.get(Position);
if (
entityToFollowPosition === undefined ||
entityToFollowPosition === null
) {
throw new Error(
`Entity with ID ${camera.followEntity} to follow does not have a Position component.`
);
}
// Set position to be same as entityToFollow
position.set(
entityToFollowPosition.x,
entityToFollowPosition.y,
// Keep current Z-Index
position.z
);
}
// Update camera's actual position
world.moveCenter(position.x, position.y);
// Update z index based on z position
world.zIndex = position.z;
// Update rotation if applicable
if (rotation !== undefined) {
world.angle = rotation.z;
world.pivot.set(rotation.pivot.x, rotation.pivot.y);
}
// TODO: I don't need it right now but maybe in the future, add zoom, bounds, etc.
}
}
|
Pandawan/yave
|
src/rendering/components/camera.ts
|
import { Component } from '@trixt0r/ecs';
export class Camera implements Component {
/**
* Whether or not this camera should affect the viewport.
*/
public active: boolean;
/**
* ID of the entity that the camera should be following.
* NOTE: The camera will retain its z position (zIndex).
*/
public followEntity: string | number | null;
/**
* Create a camera component.
*/
constructor(active = true) {
this.active = active;
this.followEntity = null;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.