repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
anrgct/ext-saladict
|
src/components/ShadowPortal/index.tsx
|
import React, { useMemo, useEffect, ReactNode } from 'react'
import ReactDOM from 'react-dom'
import CSSTransition, {
CSSTransitionProps
} from 'react-transition-group/CSSTransition'
import root from 'react-shadow'
import { SALADICT_EXTERNAL } from '@/_helpers/saladict'
export const defaultTimeout = { enter: 400, exit: 100, appear: 400 }
export const defaultClassNames = 'shadowPortal'
// prevent styles in shadow dom from inheriting outside rules
const styleResetBoundary: React.CSSProperties = { all: 'initial' }
export interface ShadowPortalOwnProps {
/** Unique id for the injected element */
id: string
/** Static content before the children */
head?: ReactNode
shadowRootClassName?: string
panelCSS?: string
}
export type ShadowPortalProps = ShadowPortalOwnProps & CSSTransitionProps
/**
* Render a shadow DOM on Portal to a removable element with transition.
* Insert the element to DOM when the Component mounts.
* Remove the element from DOM when the Component unmounts.
*/
export const ShadowPortal = (props: ShadowPortalProps) => {
const {
id,
head,
shadowRootClassName,
panelCSS,
onEnter,
onExited,
...restProps
} = props
const $root = useMemo(() => {
let $root = document.getElementById(id)
if (!$root) {
$root = document.createElement('div')
$root.id = id
$root.className = `saladict-div ${shadowRootClassName ||
SALADICT_EXTERNAL}`
}
return $root
}, [shadowRootClassName])
// unmout element when React node unmounts
useEffect(
() => () => {
if ($root.parentNode) {
$root.remove()
}
},
[]
)
return ReactDOM.createPortal(
<root.div className={shadowRootClassName || SALADICT_EXTERNAL}>
<div style={styleResetBoundary}>
{head}
{panelCSS ? <style>{panelCSS}</style> : null}
<CSSTransition
classNames={defaultClassNames}
mountOnEnter
unmountOnExit
appear
timeout={defaultTimeout}
{...restProps}
onEnter={(...args) => {
if (!$root.parentNode) {
document.body.appendChild($root)
}
if (onEnter) {
return onEnter(...args)
}
}}
onExited={(...args) => {
if ($root.parentNode) {
$root.remove()
}
if (onExited) {
return onExited(...args)
}
}}
/>
</div>
</root.div>,
$root
)
}
export default ShadowPortal
|
anrgct/ext-saladict
|
src/components/dictionaries/mojidict/View.tsx
|
<reponame>anrgct/ext-saladict
import React, { FC } from 'react'
import Speaker from '@/components/Speaker'
import EntryBox from '@/components/EntryBox'
import { MojidictResult } from './engine'
import { ViewPorps } from '@/components/dictionaries/helpers'
export const DictMojidict: FC<ViewPorps<MojidictResult>> = ({ result }) => (
<>
{result.word && (
<div>
<h1>{result.word.spell}</h1>
<span>{result.word.pron}</span> <Speaker src={result.word.tts} />
</div>
)}
{result.details &&
result.details.map(detail => (
<EntryBox key={detail.title} title={detail.title}>
{detail.subdetails && (
<ul className="dictMojidict-List">
{detail.subdetails.map(subdetail => (
<li
key={subdetail.title}
className="dictMojidict-ListItem_Disc"
>
<p>{subdetail.title}</p>
{subdetail.examples && (
<ul className="dictMojidict-Sublist">
{subdetail.examples.map(example => (
<li key={example.title}>
<p className="dictMojidict-Word_Title">
{example.title}
</p>
<p className="dictMojidict-Word_Trans">
{example.trans}
</p>
</li>
))}
</ul>
)}
</li>
))}
</ul>
)}
</EntryBox>
))}
{result.releated && (
<EntryBox title="関連用語">
<ul className="dictMojidict-List">
{result.releated.map(word => (
<li key={word.title}>
<p className="dictMojidict-Word_Title">{word.title}</p>
<p className="dictMojidict-Word_Trans">{word.excerpt}</p>
</li>
))}
</ul>
</EntryBox>
)}
</>
)
export default DictMojidict
|
anrgct/ext-saladict
|
src/components/Speaker/Speaker.stories.tsx
|
<filename>src/components/Speaker/Speaker.stories.tsx<gh_stars>1-10
import React from 'react'
import { storiesOf } from '@storybook/react'
import { action } from '@storybook/addon-actions'
import { withKnobs, text, number } from '@storybook/addon-knobs'
import { jsxDecorator } from 'storybook-addon-jsx'
import { withPropsTable } from 'storybook-addon-react-docgen'
import {
withSaladictPanel,
withSideEffect,
mockRuntimeMessage
} from '@/_helpers/storybook'
import {
Speaker,
StaticSpeakerContainer,
getStaticSpeakerString,
getStaticSpeaker
} from './index'
import { timer } from '@/_helpers/promise-more'
storiesOf('Content Scripts|Components', module)
.addDecorator(withPropsTable)
.addDecorator(jsxDecorator)
.addDecorator(withKnobs)
.addDecorator(
withSideEffect(
mockRuntimeMessage(async message => {
if (message.type === 'PLAY_AUDIO') {
action('Play Audio')(message.payload)
await timer(Math.random() * 5000)
action('Audio End')(message.payload)
}
})
)
)
.addDecorator(
withSaladictPanel({
head: <style>{require('./Speaker.scss').toString()}</style>
})
)
.add('Speaker', () => {
return (
<Speaker
width={number('Icon Width', 20)}
height={number('Icon Height', 20)}
src={text('Audio URL', 'https://example.com/a.mp3')}
></Speaker>
)
})
.add('StaticSpeakerContainer', () => {
const textStr = text(
'Audio URL for getStaticSpeakerString',
'https://example.com/a.mp3'
)
const textNode = text(
'Audio URL for getStaticSpeaker',
'https://example.com/b.mp3'
)
const node = getStaticSpeaker(textNode)
return (
<StaticSpeakerContainer
onPlayStart={async src => action('On Play Start')(src)}
>
<div
dangerouslySetInnerHTML={{
__html: `
<p>${getStaticSpeakerString(textStr)} ${textStr}</p>
<p>${node && node.outerHTML} ${textNode}</p>
`
}}
></div>
</StaticSpeakerContainer>
)
})
|
anrgct/ext-saladict
|
src/components/dictionaries/cambridge/View.tsx
|
import React, { FC } from 'react'
import { CambridgeResult } from './engine'
import { ViewPorps } from '@/components/dictionaries/helpers'
export const DictCambridge: FC<ViewPorps<CambridgeResult>> = props => (
<>
{props.result.map((entry, i) => (
<section
key={i}
className="dictCambridge-Entry"
onClick={handleEntryClick}
>
<div dangerouslySetInnerHTML={{ __html: entry }} />
</section>
))}
</>
)
export default DictCambridge
function handleEntryClick(e: React.MouseEvent<HTMLElement>) {
const target = e.nativeEvent.target as HTMLDivElement
if (target && target.classList) {
if (target.classList.contains('js-accord')) {
target.classList.toggle('open')
}
if (target.classList.contains('daccord_h')) {
target.parentElement!.classList.toggle('open')
}
}
}
|
anrgct/ext-saladict
|
src/options/components/SaladictForm/SaveBtn.tsx
|
import React, { FC } from 'react'
import { useObservableGetState } from 'observable-hooks'
import { uploadResult$$ } from '@/options/helpers/upload'
import { Button } from 'antd'
import { useTranslate } from '@/_helpers/i18n'
/**
* Move the button out as independent component to reduce
* re-rendering of the whole component.
*/
export const SaveBtn: FC = () => {
const { t } = useTranslate('common')
const uploading = useObservableGetState(uploadResult$$, 'loading')
return (
<Button type="primary" htmlType="submit" disabled={uploading}>
{t('common:save')}
</Button>
)
}
|
anrgct/ext-saladict
|
src/options/components/Entries/QuickSearch/StandaloneModal.tsx
|
import React, { FC } from 'react'
import { Select, Slider, Switch } from 'antd'
import { useTranslate } from '@/_helpers/i18n'
import { getConfigPath } from '@/options/helpers/path-joiner'
import { SaladictModalForm } from '@/options/components/SaladictModalForm'
import { pixelSlideFormatter } from '@/options/components/SaladictForm'
import { searchMode } from '../SearchModes/searchMode'
export interface StandaloneModalProps {
show: boolean
onClose: () => void
}
export const StandaloneModal: FC<StandaloneModalProps> = ({
show,
onClose
}) => {
const { t } = useTranslate(['options', 'common'])
const { availHeight } = window.screen
return (
<SaladictModalForm
title={t(getConfigPath('qsStandalone'))}
visible={show}
onClose={onClose}
items={[
{
name: getConfigPath('qssaSidebar'),
children: (
<Select>
<Select.Option value="">{t('common:none')}</Select.Option>
<Select.Option value="left">{t('locations.LEFT')}</Select.Option>
<Select.Option value="right">
{t('locations.RIGHT')}
</Select.Option>
</Select>
)
},
{
name: getConfigPath('qssaHeight'),
hide: values => values[getConfigPath('qssaSidebar')],
children: (
<Slider
tipFormatter={pixelSlideFormatter}
min={250}
max={availHeight}
marks={{ 250: '250px', [availHeight]: `${availHeight}px` }}
/>
)
},
{
name: getConfigPath('qssaRectMemo'),
valuePropName: 'checked',
children: <Switch />
},
{
name: getConfigPath('qssaPageSel'),
valuePropName: 'checked',
children: <Switch />
},
searchMode('qsPanelMode', t)
]}
/>
)
}
|
anrgct/ext-saladict
|
src/background/server.ts
|
import { message, openURL } from '@/_helpers/browser-api'
import { timeout, timer } from '@/_helpers/promise-more'
import { getSuggests } from '@/_helpers/getSuggests'
import { injectDictPanel } from '@/_helpers/injectSaladictInternal'
import { newWord } from '@/_helpers/record-manager'
import { Message, MessageResponse } from '@/typings/message'
import {
SearchFunction,
DictSearchResult
} from '@/components/dictionaries/helpers'
import {
syncServiceInit,
syncServiceDownload,
syncServiceUpload
} from './sync-manager'
import {
isInNotebook,
saveWord,
deleteWords,
getWordsByText,
getWords
} from './database'
import { AudioManager } from './audio-manager'
import { QsPanelManager } from './windows-manager'
import { getTextFromClipboard } from './clipboard-manager'
import './types'
import { DictID } from '@/app-config'
/**
* background script as transfer station
*/
export class BackgroundServer {
private static instance: BackgroundServer
static getInstance() {
return (
BackgroundServer.instance ||
(BackgroundServer.instance = new BackgroundServer())
)
}
static init = BackgroundServer.getInstance
static getDictEngine(id: DictID) {
return import(
/* webpackInclude: /engine\.ts$/ */
/* webpackMode: "lazy" */
`@/components/dictionaries/${id}/engine.ts`
)
}
private qsPanelManager: QsPanelManager
// singleton
private constructor() {
this.qsPanelManager = new QsPanelManager()
message.addListener((msg, sender: browser.runtime.MessageSender) => {
switch (msg.type) {
case 'OPEN_DICT_SRC_PAGE':
return this.openSrcPage(msg.payload)
case 'OPEN_URL':
return openURL(msg.payload.url, msg.payload.self)
case 'PLAY_AUDIO':
return AudioManager.getInstance().play(msg.payload)
case 'FETCH_DICT_RESULT':
return this.fetchDictResult(msg.payload)
case 'DICT_ENGINE_METHOD':
return this.callDictEngineMethod(msg.payload)
case 'GET_CLIPBOARD':
return Promise.resolve(getTextFromClipboard())
case 'INJECT_DICTPANEL':
return injectDictPanel(sender.tab)
case 'QUERY_QS_PANEL':
return this.qsPanelManager.hasCreated()
case 'OPEN_QS_PANEL':
return this.openQSPanel()
case 'CLOSE_QS_PANEL':
return this.qsPanelManager.destroy()
case 'QS_SWITCH_SIDEBAR':
return this.qsPanelManager.toggleSidebar(msg.payload)
case 'IS_IN_NOTEBOOK':
return isInNotebook(msg.payload)
case 'SAVE_WORD':
return saveWord(msg.payload).then(response => {
setTimeout(() => message.send({ type: 'WORD_SAVED' }), 0)
return response
})
case 'DELETE_WORDS':
return deleteWords(msg.payload).then(response => {
setTimeout(() => message.send({ type: 'WORD_SAVED' }), 0)
return response
})
case 'GET_WORDS_BY_TEXT':
return getWordsByText(msg.payload)
case 'GET_WORDS':
return getWords(msg.payload)
case 'GET_SUGGESTS':
return getSuggests(msg.payload)
case 'SYNC_SERVICE_INIT':
return syncServiceInit(msg.payload)
case 'SYNC_SERVICE_DOWNLOAD':
return syncServiceDownload(msg.payload)
case 'SYNC_SERVICE_UPLOAD':
return syncServiceUpload(msg.payload)
case 'YOUDAO_TRANSLATE_AJAX':
return this.youdaoTranslateAjax(msg.payload)
}
})
}
async openQSPanel(): Promise<void> {
if (await this.qsPanelManager.hasCreated()) {
this.qsPanelManager.focus()
return
}
await this.qsPanelManager.create()
}
async searchClipboard(): Promise<void> {
const text = getTextFromClipboard()
if (!text) return
const word = newWord({ text })
if (await this.qsPanelManager.hasCreated()) {
await message.send({
type: 'QS_PANEL_SEARCH_TEXT',
payload: word
})
return
}
await this.qsPanelManager.create(word)
if (!window.appConfig.qsAuto) {
await timer(1000)
await message.send({
type: 'QS_PANEL_SEARCH_TEXT',
payload: word
})
}
}
async openSrcPage({
id,
text
}: Message<'OPEN_DICT_SRC_PAGE'>['payload']): Promise<void> {
const engine = await BackgroundServer.getDictEngine(id)
return openURL(
await engine.getSrcPage(text, window.appConfig, window.activeProfile)
)
}
async fetchDictResult(
data: Message<'FETCH_DICT_RESULT'>['payload']
): Promise<MessageResponse<'FETCH_DICT_RESULT'>> {
let search: SearchFunction<
DictSearchResult<any>,
NonNullable<typeof data['payload']>
>
try {
;({ search } = await BackgroundServer.getDictEngine(data.id))
} catch (err) {
return Promise.reject(err)
}
const payload = data.payload || {}
return timeout(
search(data.text, window.appConfig, window.activeProfile, payload),
25000
)
.catch(async (err: Error) => {
if (process.env.DEBUG) {
console.warn(data.id, err)
}
if (err.message === 'NETWORK_ERROR') {
// retry once
await timer(500)
return timeout(
search(data.text, window.appConfig, window.activeProfile, payload),
25000
)
}
return Promise.reject(err)
})
.then(response => ({ ...response, id: data.id }))
.catch(err => {
if (process.env.DEBUG) {
console.warn(data.id, err)
}
return { result: null, id: data.id }
})
}
async callDictEngineMethod(data: Message<'DICT_ENGINE_METHOD'>['payload']) {
const engine = await BackgroundServer.getDictEngine(data.id)
return engine[data.method](...(data.args || []))
}
/** Bypass http restriction */
youdaoTranslateAjax(request: any): Promise<any> {
return new Promise(resolve => {
const xhr = new XMLHttpRequest()
xhr.onreadystatechange = () => {
if (xhr.readyState === 4) {
const data = xhr.status === 200 ? xhr.responseText : null
resolve({
response: data,
index: request.index
})
}
}
xhr.open(request.type, request.url, true)
if (request.type === 'POST') {
xhr.setRequestHeader(
'Content-Type',
'application/x-www-form-urlencoded'
)
xhr.send(request.data)
} else {
xhr.send(null as any)
}
})
}
}
|
anrgct/ext-saladict
|
src/options/data.ts
|
import { createContext } from 'react'
import { ConnectableObservable } from 'rxjs'
import { publishReplay } from 'rxjs/operators'
import { ProfileIDList, Profile } from '@/app-config/profiles'
import { AppConfig } from '@/app-config'
import { createConfigStream } from '@/_helpers/config-manager'
import {
createActiveProfileStream,
createProfileIDListStream
} from '@/_helpers/profile-manager'
export const config$$ = createConfigStream().pipe(publishReplay(1))
;(config$$ as ConnectableObservable<AppConfig>).connect()
export const profile$$ = createActiveProfileStream().pipe(publishReplay(1))
;(profile$$ as ConnectableObservable<Profile>).connect()
export const profileIDList$$ = createProfileIDListStream().pipe(
publishReplay(1)
)
;(profileIDList$$ as ConnectableObservable<ProfileIDList>).connect()
export interface GlobalsContext {
/** Unsaved form? */
dirty: boolean
config: AppConfig
profile: Profile
profileIDList: ProfileIDList
}
export const GlobalsContext = createContext(
(null as unknown) as Readonly<GlobalsContext>
)
|
anrgct/ext-saladict
|
src/components/AntdRoot/index.tsx
|
<filename>src/components/AntdRoot/index.tsx<gh_stars>0
import React, { FC, useEffect } from 'react'
import { Provider as ReduxProvider } from 'react-redux'
import createStore from '@/content/redux/create'
import { useRefFn, useObservableState, useObservable } from 'observable-hooks'
import { distinctUntilChanged, map, startWith } from 'rxjs/operators'
import SaladBowlContainer from '@/content/components/SaladBowl/SaladBowl.container'
import DictPanelContainer from '@/content/components/DictPanel/DictPanel.container'
import WordEditorContainer from '@/content/components/WordEditor/WordEditor.container'
import { createConfigStream } from '@/_helpers/config-manager'
import { reportGA } from '@/_helpers/analytics'
import { I18nContextProvider } from '@/_helpers/i18n'
import { timer } from '@/_helpers/promise-more'
import { ConfigProvider as AntdConfigProvider } from 'antd'
import zh_CN from 'antd/lib/locale-provider/zh_CN'
import zh_TW from 'antd/lib/locale-provider/zh_TW'
import en_US from 'antd/lib/locale-provider/en_US'
import './_style.scss'
const antdLocales = {
'zh-CN': zh_CN,
'zh-TW': zh_TW,
en: en_US
}
export interface AntdRootProps {
/** analytics path */
path?: string
}
export const AntdRoot: FC<AntdRootProps> = props => {
const storeRef = useRefFn(createStore)
const { locale, bgStyle, analytics } = useObservableState(
useObservable(() =>
createConfigStream().pipe(
distinctUntilChanged(
(oldConfig, newConfig) =>
oldConfig.langCode === newConfig.langCode &&
oldConfig.darkMode === newConfig.darkMode &&
oldConfig.analytics === newConfig.analytics
),
map(config => ({
locale: antdLocales[config.langCode] || en_US,
bgStyle: { backgroundColor: config.darkMode ? '#000' : '#f0f2f5' },
analytics: config.analytics
})),
startWith({
locale: zh_CN,
bgStyle: { backgroundColor: '#f0f2f5' },
analytics: false
})
)
)
)!
useEffect(() => {
if (analytics && props.path) {
reportGA(props.path)
}
}, [analytics, props.path])
return (
<I18nContextProvider>
<ReduxProvider store={storeRef.current}>
<AntdConfigProvider locale={locale}>
<div style={bgStyle}>{props.children}</div>
</AntdConfigProvider>
<SaladBowlContainer />
<DictPanelContainer />
<WordEditorContainer />
</ReduxProvider>
</I18nContextProvider>
)
}
export async function switchAntdTheme(darkMode: boolean): Promise<void> {
const $root = document.querySelector('#root')!
await new Promise(resolve => {
const filename = `antd${darkMode ? '.dark' : ''}.min.css`
const href =
process.env.NODE_ENV === 'development'
? `https://cdnjs.cloudflare.com/ajax/libs/antd/4.1.0/${filename}`
: `/assets/${filename}`
let $link = document.head.querySelector<HTMLLinkElement>(
'link#saladict-antd-theme'
)
if ($link && $link.getAttribute('href') === href) {
resolve()
return
}
// smooth dark/bright transition
$root.classList.toggle('saladict-theme-dark', darkMode)
$root.classList.toggle('saladict-theme-bright', !darkMode)
$root.classList.toggle('saladict-theme-loading', true)
if ($link) {
$link.setAttribute('href', href)
} else {
$link = document.createElement('link')
$link.setAttribute('id', 'saladict-antd-theme')
$link.setAttribute('rel', 'stylesheet')
$link.setAttribute('href', href)
document.head.insertBefore($link, document.head.firstChild)
}
let loaded = false
// @ts-ignore
$link.onreadystatechange = function() {
// @ts-ignore
if (this.readyState === 'complete' || this.readyState === 'loaded') {
if (loaded === false) {
resolve()
}
loaded = true
}
}
$link.onload = function() {
if (loaded === false) {
resolve()
}
loaded = true
}
const img = document.createElement('img')
img.onerror = function() {
if (loaded === false) {
resolve()
}
loaded = true
}
img.src = href
})
await timer(100)
setTimeout(() => {
$root.classList.toggle('saladict-theme-loaded', true)
$root.classList.toggle('saladict-theme-loading', false)
}, 400)
}
|
anrgct/ext-saladict
|
src/options/helpers/path-joiner.ts
|
import { AppConfig } from '@/app-config'
import { Profile } from '@/app-config/profiles'
import { useRefFn } from 'observable-hooks'
export function getConfigPath<A extends keyof AppConfig>(pA: A): string
export function getConfigPath<
A extends keyof AppConfig,
B extends keyof AppConfig[A]
>(pA: A, pB: B): string
export function getConfigPath<
A extends keyof AppConfig,
B extends keyof AppConfig[A],
C extends keyof AppConfig[A][B]
>(pA: A, pB: B, pC: C): string
export function getConfigPath<
A extends keyof AppConfig,
B extends keyof AppConfig[A],
C extends keyof AppConfig[A][B],
D extends keyof AppConfig[A][B][C]
>(pA: A, pB: B, pC: C, pD: D): string
export function getConfigPath<
A extends keyof AppConfig,
B extends keyof AppConfig[A],
C extends keyof AppConfig[A][B],
D extends keyof AppConfig[A][B][C],
E extends keyof AppConfig[A][B][C][D]
>(pA: A, pB: B, pC: C, pD: D, pE: E): string
export function getConfigPath<
A extends keyof AppConfig,
B extends keyof AppConfig[A],
C extends keyof AppConfig[A][B],
D extends keyof AppConfig[A][B][C],
E extends keyof AppConfig[A][B][C][D],
F extends keyof AppConfig[A][B][C][D][E]
>(pA: A, pB: B, pC: C, pD: D, pE: E, pF: F): string
export function getConfigPath<
A extends keyof AppConfig,
B extends keyof AppConfig[A],
C extends keyof AppConfig[A][B],
D extends keyof AppConfig[A][B][C],
E extends keyof AppConfig[A][B][C][D],
F extends keyof AppConfig[A][B][C][D][E],
G extends keyof AppConfig[A][B][C][D][E][F]
>(pA: A, pB: B, pC: C, pD: D, pE: E, pF: F, pG: G): string
export function getConfigPath<
A extends keyof AppConfig,
B extends keyof AppConfig[A],
C extends keyof AppConfig[A][B],
D extends keyof AppConfig[A][B][C],
E extends keyof AppConfig[A][B][C][D],
F extends keyof AppConfig[A][B][C][D][E],
G extends keyof AppConfig[A][B][C][D][E][F],
H extends keyof AppConfig[A][B][C][D][E][F][G]
>(pA: A, pB: B, pC: C, pD: D, pE: E, pF: F, pG: G, pH: H): string
export function getConfigPath<
A extends keyof AppConfig,
B extends keyof AppConfig[A],
C extends keyof AppConfig[A][B],
D extends keyof AppConfig[A][B][C],
E extends keyof AppConfig[A][B][C][D],
F extends keyof AppConfig[A][B][C][D][E],
G extends keyof AppConfig[A][B][C][D][E][F],
H extends keyof AppConfig[A][B][C][D][E][F][G],
I extends keyof AppConfig[A][B][C][D][E][F][G][H]
>(pA: A, pB: B, pC: C, pD: D, pE: E, pF: F, pG: G, pH: H, pI: I): string
export function getConfigPath<
A extends keyof AppConfig,
B extends keyof AppConfig[A],
C extends keyof AppConfig[A][B],
D extends keyof AppConfig[A][B][C],
E extends keyof AppConfig[A][B][C][D],
F extends keyof AppConfig[A][B][C][D][E],
G extends keyof AppConfig[A][B][C][D][E][F],
H extends keyof AppConfig[A][B][C][D][E][F][G],
I extends keyof AppConfig[A][B][C][D][E][F][G][H],
J extends keyof AppConfig[A][B][C][D][E][F][G][H][I]
>(pA: A, pB: B, pC: C, pD: D, pE: E, pF: F, pG: G, pH: H, pI: I, pJ: J): string
export function getConfigPath<
A extends keyof AppConfig,
B extends keyof AppConfig[A],
C extends keyof AppConfig[A][B],
D extends keyof AppConfig[A][B][C],
E extends keyof AppConfig[A][B][C][D],
F extends keyof AppConfig[A][B][C][D][E],
G extends keyof AppConfig[A][B][C][D][E][F],
H extends keyof AppConfig[A][B][C][D][E][F][G],
I extends keyof AppConfig[A][B][C][D][E][F][G][H],
J extends keyof AppConfig[A][B][C][D][E][F][G][H][I],
K extends keyof AppConfig[A][B][C][D][E][F][G][H][I][J]
>(
pA: A,
pB: B,
pC: C,
pD: D,
pE: E,
pF: F,
pG: G,
pH: H,
pI: I,
pJ: J,
pK: K
): string
export function getConfigPath(...args: string[]): string {
return 'config.' + args.join('.')
}
export const useConfigPath: typeof getConfigPath = (
...args: string[]
): string => {
return useRefFn(() => 'config.' + args.join('.')).current
}
export function getProfilePath<A extends keyof Profile>(pA: A): string
export function getProfilePath<
A extends keyof Profile,
B extends keyof Profile[A]
>(pA: A, pB: B): string
export function getProfilePath<
A extends keyof Profile,
B extends keyof Profile[A],
C extends keyof Profile[A][B]
>(pA: A, pB: B, pC: C): string
export function getProfilePath<
A extends keyof Profile,
B extends keyof Profile[A],
C extends keyof Profile[A][B],
D extends keyof Profile[A][B][C]
>(pA: A, pB: B, pC: C, pD: D): string
export function getProfilePath<
A extends keyof Profile,
B extends keyof Profile[A],
C extends keyof Profile[A][B],
D extends keyof Profile[A][B][C],
E extends keyof Profile[A][B][C][D]
>(pA: A, pB: B, pC: C, pD: D, pE: E): string
export function getProfilePath<
A extends keyof Profile,
B extends keyof Profile[A],
C extends keyof Profile[A][B],
D extends keyof Profile[A][B][C],
E extends keyof Profile[A][B][C][D],
F extends keyof Profile[A][B][C][D][E]
>(pA: A, pB: B, pC: C, pD: D, pE: E, pF: F): string
export function getProfilePath<
A extends keyof Profile,
B extends keyof Profile[A],
C extends keyof Profile[A][B],
D extends keyof Profile[A][B][C],
E extends keyof Profile[A][B][C][D],
F extends keyof Profile[A][B][C][D][E],
G extends keyof Profile[A][B][C][D][E][F]
>(pA: A, pB: B, pC: C, pD: D, pE: E, pF: F, pG: G): string
export function getProfilePath<
A extends keyof Profile,
B extends keyof Profile[A],
C extends keyof Profile[A][B],
D extends keyof Profile[A][B][C],
E extends keyof Profile[A][B][C][D],
F extends keyof Profile[A][B][C][D][E],
G extends keyof Profile[A][B][C][D][E][F],
H extends keyof Profile[A][B][C][D][E][F][G]
>(pA: A, pB: B, pC: C, pD: D, pE: E, pF: F, pG: G, pH: H): string
export function getProfilePath<
A extends keyof Profile,
B extends keyof Profile[A],
C extends keyof Profile[A][B],
D extends keyof Profile[A][B][C],
E extends keyof Profile[A][B][C][D],
F extends keyof Profile[A][B][C][D][E],
G extends keyof Profile[A][B][C][D][E][F],
H extends keyof Profile[A][B][C][D][E][F][G],
I extends keyof Profile[A][B][C][D][E][F][G][H]
>(pA: A, pB: B, pC: C, pD: D, pE: E, pF: F, pG: G, pH: H, pI: I): string
export function getProfilePath<
A extends keyof Profile,
B extends keyof Profile[A],
C extends keyof Profile[A][B],
D extends keyof Profile[A][B][C],
E extends keyof Profile[A][B][C][D],
F extends keyof Profile[A][B][C][D][E],
G extends keyof Profile[A][B][C][D][E][F],
H extends keyof Profile[A][B][C][D][E][F][G],
I extends keyof Profile[A][B][C][D][E][F][G][H],
J extends keyof Profile[A][B][C][D][E][F][G][H][I]
>(pA: A, pB: B, pC: C, pD: D, pE: E, pF: F, pG: G, pH: H, pI: I, pJ: J): string
export function getProfilePath<
A extends keyof Profile,
B extends keyof Profile[A],
C extends keyof Profile[A][B],
D extends keyof Profile[A][B][C],
E extends keyof Profile[A][B][C][D],
F extends keyof Profile[A][B][C][D][E],
G extends keyof Profile[A][B][C][D][E][F],
H extends keyof Profile[A][B][C][D][E][F][G],
I extends keyof Profile[A][B][C][D][E][F][G][H],
J extends keyof Profile[A][B][C][D][E][F][G][H][I],
K extends keyof Profile[A][B][C][D][E][F][G][H][I][J]
>(
pA: A,
pB: B,
pC: C,
pD: D,
pE: E,
pF: F,
pG: G,
pH: H,
pI: I,
pJ: J,
pK: K
): string
export function getProfilePath(...args: string[]): string {
return 'profile.' + args.join('.')
}
export const useProfilePath: typeof getProfilePath = (
...args: string[]
): string => {
return useRefFn(() => 'profile.' + args.join('.')).current
}
|
anrgct/ext-saladict
|
src/_locales/en/content.ts
|
<gh_stars>0
import { locale as _locale } from '../zh-CN/content'
export const locale: typeof _locale = {
chooseLang: 'Choose another language',
standalone: 'Saladict Standalone Panel',
fetchLangList: 'Fetch full language list',
transContext: 'Retranslate',
neverShow: 'Stop showing',
fromSaladict: 'From Saladict Panel',
tip: {
historyBack: 'Previous search history',
historyNext: 'Next search history',
searchText: 'Search text',
openOptions: 'Open Options',
addToNotebook: 'Add to Notebook. Right click to open Notebook',
openNotebook: 'Open Notebook',
openHistory: 'Open History',
shareImg: 'Share as image',
pinPanel: 'Pin the panel',
closePanel: 'Close the panel',
sidebar: 'Switch to sidebar mode. Right click to right side.',
focusPanel: 'Panel gains focus when searching',
unfocusPanel: 'Panel does not gain focus when searching'
},
wordEditor: {
title: 'Add to Notebook',
wordCardsTitle: 'Other results from Notebook',
deleteConfirm: 'Delete from Notebook?',
closeConfirm: 'Changes will not be saved. Are you sure to close?',
chooseCtxTitle: 'Pick translated results'
},
machineTrans: {
switch: 'Switch Language',
sl: 'Source Language',
tl: 'Target Language',
auto: 'Detect language',
stext: 'Original'
}
}
|
anrgct/ext-saladict
|
src/components/dictionaries/websterlearner/View.tsx
|
import React, { FC } from 'react'
import Speaker from '@/components/Speaker'
import {
WebsterLearnerResult,
WebsterLearnerResultLex,
WebsterLearnerResultRelated
} from './engine'
import { ViewPorps } from '@/components/dictionaries/helpers'
export const DictWebsterLearner: FC<ViewPorps<WebsterLearnerResult>> = ({
result
}) => {
switch (result.type) {
case 'lex':
return renderLex(result)
case 'related':
return renderRelated(result)
default:
return null
}
}
function renderLex(result: WebsterLearnerResultLex) {
return (
<>
{result.items.map(entry => (
<section key={entry.title} className="dictWebsterLearner-Entry">
<header className="dictWebsterLearner-Header">
<span
className="hw_d hw_0"
dangerouslySetInnerHTML={{ __html: entry.title }}
/>
<Speaker src={entry.pron} />
</header>
{entry.infs && (
<div className="dictWebsterLearner-Header">
<span
className="hw_infs_d"
dangerouslySetInnerHTML={{ __html: entry.infs }}
/>
<Speaker src={entry.infsPron} />
</div>
)}
{entry.labels && (
<div
className="labels"
dangerouslySetInnerHTML={{ __html: entry.labels }}
/>
)}
{entry.senses && (
<div
className="sblocks"
dangerouslySetInnerHTML={{ __html: entry.senses }}
/>
)}
{entry.arts &&
entry.arts.length > 0 &&
entry.arts.map(src => <img key={src} src={src} />)}
{entry.phrases && (
<div
className="dros"
dangerouslySetInnerHTML={{ __html: entry.phrases }}
/>
)}
{entry.derived && (
<div
className="uros"
dangerouslySetInnerHTML={{ __html: entry.derived }}
/>
)}
</section>
))}
</>
)
}
function renderRelated(result: WebsterLearnerResultRelated) {
return (
<>
<p>Did you mean:</p>
<ul
className="dictWebsterLearner-Related"
dangerouslySetInnerHTML={{ __html: result.list }}
/>
</>
)
}
export default DictWebsterLearner
|
anrgct/ext-saladict
|
test/specs/components/dictionaries/naver/requests.mock.ts
|
import { MockRequest } from '@/components/dictionaries/helpers'
export const mockSearchTexts = ['爱', '愛']
export const mockRequest: MockRequest = mock => {
mock
.onGet(new RegExp('naver.+' + encodeURIComponent('爱')))
.reply(200, require(`raw-loader!./response/爱.html`).default)
mock
.onGet(new RegExp('naver.+' + encodeURIComponent('愛')))
.reply(200, require(`raw-loader!./response/愛.html`).default)
}
|
anrgct/ext-saladict
|
src/components/dictionaries/googledict/View.tsx
|
<filename>src/components/dictionaries/googledict/View.tsx
import React, { FC } from 'react'
import { GoogleDictResult } from './engine'
import { ViewPorps } from '@/components/dictionaries/helpers'
export const DictGoogleDict: FC<ViewPorps<GoogleDictResult>> = ({ result }) => (
<div dangerouslySetInnerHTML={{ __html: result.entry }} />
)
export default DictGoogleDict
|
anrgct/ext-saladict
|
src/content/components/WordEditor/Notes.tsx
|
<reponame>anrgct/ext-saladict
import React, { FC, useState, useEffect } from 'react'
import { useUpdateEffect } from 'react-use'
import {
useObservable,
useObservableState,
useObservableCallback,
useSubscription,
pluckFirst
} from 'observable-hooks'
import { of } from 'rxjs'
import {
withLatestFrom,
switchMap,
debounceTime,
startWith
} from 'rxjs/operators'
import {
Word,
getWordsByText,
deleteWords,
saveWord
} from '@/_helpers/record-manager'
import { AppConfig } from '@/app-config'
import {
translateCtxs,
genCtxText,
CtxTranslateResults
} from '@/_helpers/translateCtx'
import { useTranslate } from '@/_helpers/i18n'
import { message } from '@/_helpers/browser-api'
import { isOptionsPage } from '@/_helpers/saladict'
import { WordCards } from './WordCards'
import { WordEditorPanel, WordEditorPanelProps } from './WordEditorPanel'
import { CSSTransition } from 'react-transition-group'
import { CtxTransList } from './CtxTransList'
export interface NotesProps
extends Pick<WordEditorPanelProps, 'containerWidth'> {
wordEditor: {
word: Word
translateCtx: boolean
}
/** dicts to translate context */
ctxTrans: AppConfig['ctxTrans']
onClose: () => void
}
const notesFadeTimeout = { enter: 400, exit: 100, appear: 400 }
export const Notes: FC<NotesProps> = props => {
const { t } = useTranslate(['common', 'content'])
const [isDirty, setDirty] = useState(false)
const [isShowCtxTransList, setShowCtxTransList] = useState(false)
const [word, setWord] = useState(props.wordEditor.word)
const word$ = useObservable(pluckFirst, [word])
const [ctxTransConfig, setCtxTransConfig] = useState(props.ctxTrans)
useUpdateEffect(() => {
setCtxTransConfig(props.ctxTrans)
}, [props.ctxTrans])
const [ctxTransResult, setCtxTransResult] = useState(() =>
Object.keys(props.ctxTrans).reduce((result, id) => {
result[id] = ''
return result
}, {} as CtxTranslateResults)
)
const [getRelatedWords, relatedWords$] = useObservableCallback<
Word[],
never,
[]
>(event$ =>
event$.pipe(
debounceTime(200),
withLatestFrom(word$),
switchMap(([, word]) => {
if (!word.text) {
return of([])
}
return getWordsByText('notebook', word.text)
.then(words => words.filter(({ date }) => date !== word.date))
.catch(() => [])
}),
startWith([])
)
)
const relatedWords = useObservableState(relatedWords$)!
const [onTranslateCtx, translateCtx$] = useObservableCallback<
CtxTranslateResults,
typeof ctxTransConfig
>(event$ =>
event$.pipe(
withLatestFrom(word$),
switchMap(([ctxTransConfig, word]) => {
return translateCtxs(word.context || word.text, ctxTransConfig)
})
)
)
useSubscription(translateCtx$, setCtxTransResult)
useEffect(() => {
if (props.wordEditor.translateCtx) {
onTranslateCtx(ctxTransConfig)
}
}, [])
useEffect(getRelatedWords, [word.text, word.context])
useUpdateEffect(() => {
setWord({
...word,
trans: genCtxText(word.trans, ctxTransResult)
})
}, [ctxTransResult])
const closeEditor = () => {
if (!isDirty || confirm(t('content:wordEditor.closeConfirm'))) {
props.onClose()
}
}
const formChanged = ({
currentTarget
}: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
setDirty(true)
setWord({
...word,
[currentTarget.name]: currentTarget.value
})
}
const panelBtns = [
{
type: 'normal',
title: t('content:transContext'),
onClick: () => onTranslateCtx(ctxTransConfig)
},
{
type: 'normal',
title: t('content:neverShow'),
onClick: () => {
if (!isOptionsPage()) {
message.send({
type: 'OPEN_URL',
payload: {
url: 'options.html?menuselected=Notebook',
self: true
}
})
}
}
},
{
type: 'normal',
title: t('cancel'),
onClick: closeEditor
},
{
type: 'primary',
title: t('save'),
onClick: () => {
saveWord('notebook', word)
.then(props.onClose)
.catch(console.error)
}
}
] as const
return (
<>
<WordEditorPanel
containerWidth={props.containerWidth}
title={t('content:wordEditor.title')}
btns={panelBtns}
onClose={closeEditor}
>
<div className="wordEditorNote-Container">
<div className="wordEditorNote">
<label htmlFor="wordEditorNote_Word">{t('note.word')}</label>
<input
type="text"
name="text"
id="wordEditorNote_Word"
value={word.text}
onChange={formChanged}
onKeyDown={stopPropagation}
/>
<label htmlFor="wordEditorNote_Context">{t('note.context')}</label>
<textarea
rows={3}
name="context"
id="wordEditorNote_Context"
value={word.context}
onChange={formChanged}
onKeyDown={stopPropagation}
/>
<div className="wordEditorNote_LabelWithBtn">
<label htmlFor="wordEditorNote_Trans">
{t('note.trans')}
<a
href="https://saladict.crimx.com/q&a.html#%E9%97%AE%EF%BC%9A%E6%B7%BB%E5%8A%A0%E7%94%9F%E8%AF%8D%E5%8F%AF%E4%B8%8D%E5%8F%AF%E4%BB%A5%E5%8A%A0%E5%85%A5%E5%8D%95%E8%AF%8D%E7%BF%BB%E8%AF%91%EF%BC%88%E8%80%8C%E4%B8%8D%E6%98%AF%E7%BF%BB%E8%AF%91%E6%95%B4%E5%8F%A5%E4%B8%8A%E4%B8%8B%E6%96%87%EF%BC%89%E3%80%82"
target="_blank"
rel="nofollow noopener noreferrer"
>
{' '}
Why?
</a>
</label>
<button onClick={() => setShowCtxTransList(true)}>
{t('content:wordEditor.chooseCtxTitle')}
</button>
</div>
<textarea
rows={10}
name="trans"
id="wordEditorNote_Trans"
value={word.trans}
onChange={formChanged}
onKeyDown={stopPropagation}
/>
<label htmlFor="wordEditorNote_Note">{t('note.note')}</label>
<textarea
rows={5}
name="note"
id="wordEditorNote_Note"
value={word.note}
onChange={formChanged}
onKeyDown={stopPropagation}
/>
<label htmlFor="wordEditorNote_SrcTitle">
{t('note.srcTitle')}
</label>
<input
type="text"
name="title"
id="wordEditorNote_SrcTitle"
value={word.title}
onChange={formChanged}
onKeyDown={stopPropagation}
/>
<label htmlFor="wordEditorNote_SrcLink">{t('note.srcLink')}</label>
<input
type="text"
name="url"
id="wordEditorNote_SrcLink"
value={word.url}
onChange={formChanged}
onKeyDown={stopPropagation}
/>
<label htmlFor="wordEditorNote_SrcFavicon">
{t('note.srcFavicon')}
{word.favicon ? (
<img
className="wordEditorNote_SrcFavicon"
src={word.favicon}
alt={t('note.srcTitle')}
/>
) : null}
</label>
<input
type="text"
name="favicon"
id="wordEditorNote_SrcFavicon"
value={word.favicon}
onChange={formChanged}
onKeyDown={stopPropagation}
/>
</div>
{relatedWords.length > 0 && (
<WordCards
words={relatedWords}
onCardDelete={word => {
if (window.confirm(t('content:wordEditor.deleteConfirm'))) {
deleteWords('notebook', [word.date]).then(getRelatedWords)
}
}}
/>
)}
</div>
</WordEditorPanel>
<CSSTransition
classNames="notes-fade"
mountOnEnter
unmountOnExit
timeout={notesFadeTimeout}
in={isShowCtxTransList}
>
{() => (
<WordEditorPanel
containerWidth={props.containerWidth - 100}
title={t('content:wordEditor.chooseCtxTitle')}
onClose={() => setShowCtxTransList(false)}
btns={[
{
type: 'normal',
title: t('content:transContext'),
onClick: () => onTranslateCtx(ctxTransConfig)
}
]}
>
<CtxTransList
word={word}
ctxTransConfig={ctxTransConfig}
ctxTransResult={ctxTransResult}
onNewCtxTransConfig={(id, enabled) => {
setCtxTransConfig(ctxTransConfig => ({
...ctxTransConfig,
[id]: enabled
}))
}}
onNewCtxTransResult={(id, content) => {
setCtxTransResult(ctxTransResult => ({
...ctxTransResult,
[id]: content
}))
}}
/>
</WordEditorPanel>
)}
</CSSTransition>
</>
)
}
function stopPropagation(e: React.KeyboardEvent<HTMLElement>) {
e.stopPropagation()
e.nativeEvent.stopPropagation()
}
|
anrgct/ext-saladict
|
src/quick-search/index.tsx
|
import './env'
import '@/selection'
import React, { FC } from 'react'
import ReactDOM from 'react-dom'
import { Helmet } from 'react-helmet'
import { message, storage } from '@/_helpers/browser-api'
import { Provider as ProviderRedux } from 'react-redux'
import createStore from '@/content/redux/create'
import { I18nContextProvider, useTranslate } from '@/_helpers/i18n'
import { DictPanelStandaloneContainer } from '@/content/components/DictPanel/DictPanelStandalone.container'
import './quick-search.scss'
document.title = 'Saladict Standalone Panel'
const Title: FC = () => {
const { t } = useTranslate('content')
return (
<Helmet>
<title>{t('standalone')}</title>
</Helmet>
)
}
const store = createStore()
ReactDOM.render(
<I18nContextProvider>
<Title />
<ProviderRedux store={store}>
<DictPanelStandaloneContainer width="100vw" height="100vh" />
</ProviderRedux>
</I18nContextProvider>,
document.getElementById('root')
)
// Firefox cannot fire 'unload' event.
window.addEventListener('beforeunload', () => {
message.send({ type: 'CLOSE_QS_PANEL' })
if (!store.getState().config.qssaSidebar) {
storage.local.set({
qssaRect: {
top: window.screenY,
left: window.screenX,
width: window.outerWidth,
height: window.outerHeight
}
})
}
})
|
anrgct/ext-saladict
|
src/content/redux/modules/state.ts
|
<reponame>anrgct/ext-saladict
import { newWord, Word } from '@/_helpers/record-manager'
import { getDefaultConfig, DictID } from '@/app-config'
import { getDefaultProfile, ProfileIDList } from '@/app-config/profiles'
import {
isQuickSearchPage,
isStandalonePage,
isOptionsPage
} from '@/_helpers/saladict'
export const initState = () => {
const config = getDefaultConfig()
return {
config,
profiles: [] as ProfileIDList,
activeProfile: getDefaultProfile(),
selection: {
word: newWord() as Word | null,
mouseX: 0,
mouseY: 0,
self: false,
dbClick: false,
altKey: false,
shiftKey: false,
ctrlKey: false,
metaKey: false,
instant: false,
force: false
},
/** Temporary disable Saladict */
isTempDisabled: false,
/**
* Is current panel a Quick Search Panel,
* which could be in a standalone window or in-page element.
*/
isQSPanel: isQuickSearchPage(),
isQSFocus: config.qsFocus,
/** is a standalone quick search panel running */
withQssaPanel: false,
wordEditor: {
isShow: false,
word: newWord(),
// translate context on start
translateCtx: false
},
isShowBowl: false,
isShowDictPanel: isStandalonePage(),
isExpandMtaBox: false,
isExpandWaveformBox: false,
isPinned: false,
/** Is current word in Notebook */
isFav: false,
bowlCoord: { x: 0, y: 0 },
/** The actual coord of dict panel might be different */
dictPanelCoord: isOptionsPage()
? { x: window.innerWidth - config.panelWidth - 20, y: 80 }
: { x: 0, y: 0 },
panelHeight: 30,
_panelHeightCache: {
menubar: 30,
mtabox: 0,
dictlist: 0,
waveformbox: 0,
sum: 30,
/** independent layer */
floatHeight: 0
},
panelMaxHeight: window.innerHeight * 0.8,
/** Dicts that will be rendered to dict panel */
renderedDicts: [] as {
readonly id: DictID
readonly searchStatus: 'IDLE' | 'SEARCHING' | 'FINISH'
readonly searchResult: any
}[],
/** User manually folded or unfolded */
userFoldedDicts: {} as { [id in DictID]?: boolean },
/** Search text */
text: '',
/** 0 is the oldest */
searchHistory: [] as Word[],
/** User can view back search history */
historyIndex: -1,
/** Record init coordinate on dragstart */
dragStartCoord: null as null | { x: number; y: number },
lastPlayAudio: null as null | { src: string; timestamp: number }
}
}
export type State = ReturnType<typeof initState>
export default initState
|
anrgct/ext-saladict
|
src/options/components/Entries/Dictionaries/AllDicts.tsx
|
<gh_stars>0
import React, { FC, useContext, useMemo } from 'react'
import { Card, List, Switch } from 'antd'
import { GlobalsContext } from '@/options/data'
import { objectKeys } from '@/typings/helpers'
import { DictTitle } from './DictTitle'
import { DictID } from '@/app-config'
import { useFixedMemo } from '@/_helpers/hooks'
export interface AllDictsProps {
value?: DictID[]
onChange?: (list: DictID[]) => void
}
/**
* Antd form item compatible list
*/
export const AllDicts: FC<AllDictsProps> = props => {
const globals = useContext(GlobalsContext)
const all = useFixedMemo(() => objectKeys(globals.profile.dicts.all))
const selected = useMemo(() => new Set(props.value || []), [props.value])
return (
<Card>
<List
size="large"
dataSource={all}
renderItem={dictID => (
<List.Item>
<div className="sortable-list-item">
<DictTitle
dictID={dictID}
dictLangs={globals.profile.dicts.all[dictID].lang}
/>
<Switch
checked={selected.has(dictID)}
onChange={checked => {
if (props.onChange && props.value) {
props.onChange(
checked
? [...props.value, dictID]
: props.value.filter(id => id !== dictID)
)
}
}}
/>
</div>
</List.Item>
)}
/>
</Card>
)
}
|
anrgct/ext-saladict
|
src/options/components/Entries/Notebook/index.tsx
|
<filename>src/options/components/Entries/Notebook/index.tsx
import React, { FC, useContext, useState } from 'react'
import { Switch, Checkbox, Button } from 'antd'
import { concat, from } from 'rxjs'
import { pluck } from 'rxjs/operators'
import { useObservableState, useObservable } from 'observable-hooks'
import { objectKeys } from '@/typings/helpers'
import { useTranslate } from '@/_helpers/i18n'
import { storage } from '@/_helpers/browser-api'
import { getConfigPath } from '@/options/helpers/path-joiner'
import { SaladictForm } from '@/options/components/SaladictForm'
import { GlobalsContext } from '@/options/data'
import {
Service as WebDAVService,
SyncConfig as WebDAVConfig
} from '@/background/sync-manager/services/webdav'
import {
Service as ShanbayService,
SyncConfig as ShanbayConfig
} from '@/background/sync-manager/services/shanbay'
import { ShanbayModal } from './ShanbayModal'
import { WebdavModal } from './WebdavModal'
interface SyncConfigs {
[WebDAVService.id]?: WebDAVConfig
[ShanbayService.id]?: ShanbayConfig
}
export const Notebook: FC = () => {
const { t } = useTranslate(['options', 'dicts', 'common'])
const globals = useContext(GlobalsContext)
const [showWebdav, setShowWebdav] = useState(false)
const [showShanbay, setShowshanbay] = useState(false)
const syncConfigs = useObservableState<SyncConfigs>(
useObservable(() =>
concat(
from(storage.sync.get('syncConfig')).pipe(pluck('syncConfig')),
storage.sync.createStream('syncConfig').pipe(pluck('newValue'))
)
)
)
return (
<>
<SaladictForm
items={[
{
name: getConfigPath('editOnFav'),
valuePropName: 'checked',
children: <Switch />
},
{
name: getConfigPath('searchHistory'),
valuePropName: 'checked',
children: <Switch />
},
{
name: getConfigPath('searchHistoryInco'),
hide: values => !values[getConfigPath('searchHistory')],
valuePropName: 'checked',
children: <Switch />
},
{
key: getConfigPath('ctxTrans'),
style: { marginBottom: 10 },
items: objectKeys(globals.config.ctxTrans).map(id => ({
name: getConfigPath('ctxTrans', id),
valuePropName: 'checked',
style: { marginBottom: 0 },
children: <Checkbox>{t(`dicts:${id}.name`)}</Checkbox>
}))
},
{
key: 'syncService.btn.webdav',
style: { marginBottom: 15 },
children: (
<Button onClick={() => setShowWebdav(true)}>{`${t(
'syncService.btn.webdav'
)} (${t(
syncConfigs?.[WebDAVService.id]?.url
? 'common:enabled'
: 'common:disabled'
)})`}</Button>
)
},
{
key: 'syncService.btn.shanbay',
children: (
<Button onClick={() => setShowshanbay(true)}>{`${t(
'syncService.btn.shanbay'
)} (${t(
syncConfigs?.[ShanbayService.id]?.enable
? 'common:enabled'
: 'common:disabled'
)})`}</Button>
)
}
]}
/>
<ShanbayModal
syncConfig={syncConfigs?.[ShanbayService.id]}
show={showShanbay}
onClose={() => setShowshanbay(false)}
/>
<WebdavModal
syncConfig={syncConfigs?.[WebDAVService.id]}
show={showWebdav}
onClose={() => setShowWebdav(false)}
/>
</>
)
}
|
anrgct/ext-saladict
|
src/components/dictionaries/sogou/engine.ts
|
import {
MachineTranslatePayload,
MachineTranslateResult,
SearchFunction,
GetSrcPageFunction,
getMTArgs
} from '../helpers'
import memoizeOne from 'memoize-one'
import { Sogou } from '@opentranslate/sogou'
import { SogouLanguage } from './config'
export const getTranslator = memoizeOne(
() =>
new Sogou({
env: 'ext',
config:
process.env.SOGOU_PID && process.env.SOGOU_KEY
? {
pid: process.env.SOGOU_PID,
key: process.env.SOGOU_KEY
}
: undefined
})
)
export const getSrcPage: GetSrcPageFunction = (text, config, profile) => {
const lang =
profile.dicts.all.sogou.options.tl === 'default'
? config.langCode === 'zh-CN'
? 'zh-CHS'
: config.langCode === 'zh-TW'
? 'zh-CHT'
: 'en'
: profile.dicts.all.sogou.options.tl
return `https://fanyi.sogou.com/#auto/${lang}/${text}`
}
export type SogouResult = MachineTranslateResult<'sogou'>
export const search: SearchFunction<
SogouResult,
MachineTranslatePayload<SogouLanguage>
> = async (rawText, config, profile, payload) => {
const translator = getTranslator()
const { sl, tl, text } = await getMTArgs(
translator,
rawText,
profile.dicts.all.sogou,
config,
payload
)
const pid = config.dictAuth.sogou.pid
const key = config.dictAuth.sogou.key
const translatorConfig = pid && key ? { pid, key } : undefined
try {
const result = await translator.translate(text, sl, tl, translatorConfig)
return {
result: {
id: 'sogou',
sl: result.from,
tl: result.to,
langcodes: translator.getSupportLanguages(),
searchText: result.origin,
trans: result.trans
},
audio: {
py: result.trans.tts,
us: result.trans.tts
}
}
} catch (e) {
return {
result: {
id: 'sogou',
sl,
tl,
langcodes: translator.getSupportLanguages(),
searchText: { paragraphs: [''] },
trans: { paragraphs: [''] }
}
}
}
}
|
anrgct/ext-saladict
|
src/content/components/DictItem/DictItemBody.tsx
|
import React, { ComponentType, FC, useMemo, Suspense } from 'react'
import classNames from 'classnames'
import root from 'react-shadow'
import { DictID } from '@/app-config'
import { Word } from '@/_helpers/record-manager'
import { SALADICT_PANEL } from '@/_helpers/saladict'
import { ViewPorps } from '@/components/dictionaries/helpers'
import { ErrorBoundary } from '@/components/ErrorBoundary'
import { StaticSpeakerContainer } from '@/components/Speaker'
const dictContentStyles = require('./DictItemContent.shadow.scss').toString()
export interface DictItemBodyProps {
dictID: DictID
withAnimation: boolean
panelCSS: string
searchStatus: 'IDLE' | 'SEARCHING' | 'FINISH'
searchResult?: object | null
searchText: (arg?: {
id?: DictID
word?: Word
payload?: { [index: string]: any }
}) => any
onSpeakerPlay: (src: string) => Promise<void>
onInPanelSelect: (e: React.MouseEvent<HTMLElement>) => void
}
export const DictItemBody: FC<DictItemBodyProps> = props => {
const Dict = useMemo(
() =>
React.lazy<ComponentType<ViewPorps<any>>>(() =>
import(
/* webpackInclude: /View\.tsx$/ */
/* webpackMode: "lazy" */
`@/components/dictionaries/${props.dictID}/View.tsx`
)
),
[props.dictID]
)
const DictStyle = useMemo(
() =>
React.lazy(async () => {
const styleModule = await import(
/* webpackInclude: /_style\.shadow\.scss$/ */
/* webpackMode: "lazy" */
`@/components/dictionaries/${props.dictID}/_style.shadow.scss`
)
return {
default: () => (
<style>{(styleModule.default || styleModule).toString()}</style>
)
}
}),
[props.dictID]
)
return (
<ErrorBoundary error={DictRenderError}>
<Suspense fallback={null}>
{props.searchStatus === 'FINISH' && props.searchResult && (
<root.div>
<style>{dictContentStyles}</style>
<DictStyle />
{props.panelCSS ? <style>{props.panelCSS}</style> : null}
<StaticSpeakerContainer
className={classNames(
`d-${props.dictID}`,
'dictRoot',
SALADICT_PANEL,
{ isAnimate: props.withAnimation }
)}
onPlayStart={props.onSpeakerPlay}
onMouseUp={props.onInPanelSelect}
>
<Dict result={props.searchResult} searchText={props.searchText} />
</StaticSpeakerContainer>
</root.div>
)}
</Suspense>
</ErrorBoundary>
)
}
function DictRenderError() {
return (
<p style={{ textAlign: 'center' }}>
Render error. Please{' '}
<a
href="https://github.com/crimx/ext-saladict/issues"
target="_blank"
rel="nofollow noopener noreferrer"
>
report issue
</a>
.
</p>
)
}
|
anrgct/ext-saladict
|
src/history/index.tsx
|
<filename>src/history/index.tsx
import './env'
import '@/selection'
import React from 'react'
import ReactDOM from 'react-dom'
import { WordPage } from '@/components/WordPage'
import { AntdRoot, switchAntdTheme } from '@/components/AntdRoot'
import { createConfigStream } from '@/_helpers/config-manager'
document.title = 'Saladict History'
const rendered = false
createConfigStream().subscribe(async config => {
await switchAntdTheme(config.darkMode)
if (!rendered) {
ReactDOM.render(
<AntdRoot path="/wordpage/history">
<WordPage area="history" />
</AntdRoot>,
document.getElementById('root')
)
}
})
|
anrgct/ext-saladict
|
src/background/pdf-sniffer.ts
|
<filename>src/background/pdf-sniffer.ts
/**
* Open pdf link directly
*/
import { AppConfig } from '@/app-config'
import { addConfigListener } from '@/_helpers/config-manager'
import { openURL } from '@/_helpers/browser-api'
export function init(config: AppConfig) {
if (browser.webRequest.onBeforeRequest.hasListener(otherPdfListener)) {
return
}
if (config.pdfSniff) {
startListening()
}
addConfigListener(({ newConfig, oldConfig }) => {
if (newConfig) {
if (!oldConfig || newConfig.pdfSniff !== oldConfig.pdfSniff) {
if (newConfig.pdfSniff) {
startListening()
} else {
stopListening()
}
}
}
})
}
/**
* @param url provide a url
* @param force load the current tab anyway
*/
export async function openPDF(url?: string, force?: boolean) {
let pdfURL = browser.runtime.getURL('assets/pdf/web/viewer.html')
if (url) {
pdfURL += '?file=' + encodeURIComponent(url)
} else {
const tabs = await browser.tabs.query({ active: true, currentWindow: true })
if (tabs.length > 0 && tabs[0].url) {
const curURL = tabs[0].url
if (curURL.startsWith(pdfURL)) {
if (window.appConfig.pdfStandalone) {
if (tabs[0].id != null) {
await browser.tabs.remove(tabs[0].id)
}
pdfURL = curURL
} else {
return // ignore pdf viewer url
}
} else if (force || curURL.endsWith('pdf')) {
pdfURL += '?file=' + encodeURIComponent(curURL)
}
}
}
return window.appConfig.pdfStandalone
? openPDFStandalone(pdfURL)
: openURL(pdfURL)
}
export function extractPDFUrl(fullurl?: string): string | void {
if (!fullurl) {
return
}
const searchURL = new URL(fullurl)
return decodeURIComponent(searchURL.searchParams.get('file') || '')
}
function startListening() {
if (!browser.webRequest.onBeforeRequest.hasListener(otherPdfListener)) {
browser.webRequest.onBeforeRequest.addListener(
otherPdfListener,
{
urls: [
'ftp://*/*.pdf',
'ftp://*/*.PDF',
'file://*/*.pdf',
'file://*/*.PDF'
],
types: ['main_frame', 'sub_frame']
},
['blocking']
)
}
if (!browser.webRequest.onHeadersReceived.hasListener(httpPdfListener)) {
browser.webRequest.onHeadersReceived.addListener(
httpPdfListener,
{
urls: ['https://*/*', 'https://*/*', 'http://*/*', 'http://*/*'],
types: ['main_frame', 'sub_frame']
},
['blocking', 'responseHeaders']
)
}
}
function stopListening() {
browser.webRequest.onBeforeRequest.removeListener(otherPdfListener)
browser.webRequest.onHeadersReceived.removeListener(httpPdfListener)
}
function otherPdfListener({
tabId,
url
}: Parameters<
Parameters<typeof browser.webRequest.onBeforeRequest.removeListener>[0]
>[0]) {
const matchURL = ([r]: ReadonlyArray<string>) => new RegExp(r).test(url)
if (
window.appConfig.pdfBlacklist.some(matchURL) &&
!window.appConfig.pdfWhitelist.some(matchURL)
) {
return
}
const redirectUrl = browser.runtime.getURL(
`assets/pdf/web/viewer.html?file=${encodeURIComponent(url)}`
)
if (tabId !== -1 && window.appConfig.pdfStandalone === 'always') {
browser.tabs.remove(tabId)
openPDFStandalone(redirectUrl)
return { cancel: true }
}
return { redirectUrl }
}
function httpPdfListener({
tabId,
responseHeaders,
url
}: Parameters<
Parameters<typeof browser.webRequest.onHeadersReceived.removeListener>[0]
>[0]) {
if (!responseHeaders) {
return
}
const matchURL = ([r]: ReadonlyArray<string>) => new RegExp(r).test(url)
if (
window.appConfig.pdfBlacklist.some(matchURL) &&
!window.appConfig.pdfWhitelist.some(matchURL)
) {
return
}
const contentTypeHeader = responseHeaders.find(
({ name }) => name.toLowerCase() === 'content-type'
)
if (contentTypeHeader && contentTypeHeader.value) {
const contentType = contentTypeHeader.value.toLowerCase()
if (
contentType.endsWith('pdf') ||
(contentType === 'application/octet-stream' && url.endsWith('.pdf'))
) {
const redirectUrl = browser.runtime.getURL(
`assets/pdf/web/viewer.html?file=${encodeURIComponent(url)}`
)
if (tabId !== -1 && window.appConfig.pdfStandalone === 'always') {
browser.tabs.remove(tabId)
openPDFStandalone(redirectUrl)
return { cancel: true }
}
return { redirectUrl }
}
}
}
function openPDFStandalone(url: string) {
return browser.windows.create({ type: 'popup', url })
}
|
anrgct/ext-saladict
|
src/components/WordPage/ExportModal/index.tsx
|
<gh_stars>0
import React, { FC, useState, useEffect, useContext } from 'react'
import { Modal, Layout, Switch } from 'antd'
import escapeHTML from 'lodash/escape'
import { Word, newWord } from '@/_helpers/record-manager'
import { useTranslate, I18nContext } from '@/_helpers/i18n'
import { storage } from '@/_helpers/browser-api'
import { LineBreakMemo, LineBreakOption } from './Linebreak'
import { PlaceholderTableMemo } from './PlaceholderTable'
const keywordMatchStr = `%(${Object.keys(newWord()).join('|')})%`
export type ExportModalTitle = 'all' | 'selected' | 'page' | ''
export interface ExportModalProps {
title: ExportModalTitle
rawWords: Word[]
onCancel: (e: React.MouseEvent<any>) => any
}
export const ExportModal: FC<ExportModalProps> = props => {
const lang = useContext(I18nContext)
const { t } = useTranslate(['wordpage', 'common'])
const [template, setTemplate] = useState('%text%\n%trans%\n%context%\n')
const [lineBreak, setLineBreak] = useState<LineBreakOption>('')
const [escape, setEscape] = useState(false)
const [output, setOutput] = useState('')
useEffect(() => {
setOutput(
props.rawWords
.map(word =>
template.replace(new RegExp(keywordMatchStr, 'g'), (match, k) => {
switch (k) {
case 'date':
return new Date(word.date).toLocaleDateString(lang)
case 'trans':
case 'note':
case 'context': {
const text: string = escape
? escapeHTML(word[k] || '')
: word[k] || ''
switch (lineBreak) {
case 'n':
return text.replace(/\n|\r\n/g, '\\n')
case 'br':
return text.replace(/\n|\r\n/g, '<br>')
case 'p':
return text
.split(/\n|\r\n/)
.map(line => `<p>${line}</p>`)
.join('')
case 'space':
return text.replace(/\n|\r\n/g, ' ')
default:
return text
}
}
default:
return word[k] || ''
}
})
)
.join('\n')
)
}, [props.rawWords, lang, template, lineBreak, escape])
useEffect(() => {
storage.sync
.get<{
wordpageTemplate: string
wordpageLineBreak: LineBreakOption
}>(['wordpageTemplate', 'wordpageLineBreak'])
.then(({ wordpageTemplate, wordpageLineBreak }) => {
if (wordpageTemplate != null) {
setTemplate(wordpageTemplate)
}
if (wordpageLineBreak != null) {
setLineBreak(wordpageLineBreak)
}
})
storage.local
.get<{
wordpageHTMLEscape: boolean
}>('wordpageHTMLEscape')
.then(({ wordpageHTMLEscape }) => {
if (wordpageHTMLEscape != null) {
setEscape(wordpageHTMLEscape)
}
})
}, [])
const exportWords = () => {
browser.runtime.getPlatformInfo().then(({ os }) => {
const content = os === 'win' ? output.replace(/\r\n|\n/g, '\r\n') : output
const file = new Blob([content], { type: 'text/plain;charset=utf-8' })
const a = document.createElement('a')
a.style.display = 'none'
a.href = URL.createObjectURL(file)
a.download = `saladict-words-${Date.now()}.txt`
// firefox
a.target = '_blank'
document.body.appendChild(a)
a.click()
})
}
return (
<Modal
title={props.title ? t(`export.${props.title}`) : ' '}
visible={!!props.title}
destroyOnClose={true}
onOk={exportWords}
onCancel={props.onCancel}
okText={t('common:export')}
style={{ width: '90vw', maxWidth: 1200, top: 24 }}
width="90vw"
>
<Layout style={{ height: '70vh', maxHeight: 1000 }}>
<Layout.Content
style={{
display: 'flex',
flexDirection: 'column',
background: '#fff'
}}
>
<p className="export-Description">
{t('export.description')}
<a
href="https://saladict.crimx.com/anki.html"
target="_blank"
rel="nofollow noopener noreferrer"
>
{t('export.explain')}
</a>
</p>
<PlaceholderTableMemo t={t} />
<div
style={{
display: 'flex',
justifyContent: 'space-between',
alignItems: 'center',
marginBottom: '1em'
}}
>
<LineBreakMemo
t={t}
value={lineBreak}
onChange={value => {
setLineBreak(value)
storage.sync.set({ wordpageLineBreak: value })
if (value === 'br' || value === 'p') {
setEscape(true)
storage.local.set({ wordpageHTMLEscape: true })
}
}}
/>
<Switch
title={t('export.htmlescape.title')}
checked={escape}
onChange={checked => {
setEscape(checked)
storage.local.set({ wordpageHTMLEscape: checked })
}}
checkedChildren={t('export.htmlescape.text')}
unCheckedChildren={t('export.htmlescape.text')}
/>
</div>
<textarea
style={{ flex: 1, width: '100%' }}
value={template}
onChange={({ currentTarget: { value } }) => {
setTemplate(value)
storage.sync.set({ wordpageTemplate: value })
}}
/>
</Layout.Content>
<Layout.Sider
width="50%"
style={{ paddingLeft: 24, background: '#fff' }}
>
<textarea
style={{ width: '100%', height: '100%' }}
readOnly={true}
value={output}
/>
</Layout.Sider>
</Layout>
</Modal>
)
}
|
anrgct/ext-saladict
|
src/components/dictionaries/googledict/engine.ts
|
import {
HTMLString,
handleNoResult,
getInnerHTML,
removeChild,
removeChildren,
handleNetWorkError,
SearchFunction,
GetSrcPageFunction,
DictSearchResult,
getFullLink
} from '../helpers'
import { getStaticSpeaker } from '@/components/Speaker'
import { fetchPlainText } from '@/_helpers/fetch-dom'
export const getSrcPage: GetSrcPageFunction = text => {
return `https://www.google.com.hk/search?hl=en&safe=off&q=define:${text}`
}
export interface GoogleDictResult {
entry: HTMLString
}
type GoogleDictSearchResult = DictSearchResult<GoogleDictResult>
export const search: SearchFunction<GoogleDictResult> = async (
text,
config,
profile,
payload
) => {
const isen = profile.dicts.all.googledict.options.enresult
? 'hl=en&gl=en&'
: ''
const bodyText = await fetchPlainText(
`https://www.google.com/search?hl=en&safe=off&${isen}q=define:` +
encodeURIComponent(text.replace(/\s+/g, '+'))
).catch(handleNetWorkError)
return handleDOM(bodyText)
}
function handleDOM(
bodyText: string
): GoogleDictSearchResult | Promise<GoogleDictSearchResult> {
const doc = new DOMParser().parseFromString(bodyText, 'text/html')
const $obcontainer = doc.querySelector('.lr_container')
if ($obcontainer) {
$obcontainer.querySelectorAll<HTMLDivElement>('.vkc_np').forEach($block => {
if (
$block.querySelector('.zbA8Me') || // Dictionary title
$block.querySelector('#dw-siw') || // Search box
$block.querySelector('#tl_select') // Translate to
) {
$block.remove()
}
})
removeChildren($obcontainer, '.lr_dct_trns_h') // other Translate to blocks
removeChildren($obcontainer, '.S5TwIf') // Learn to pronounce
removeChildren($obcontainer, '.VZVCid') // From Oxford
removeChildren($obcontainer, '.u7XA4b') // footer
// tts
$obcontainer.querySelectorAll('audio').forEach($audio => {
const $source = $audio.querySelector('source')
if ($source) {
const src = getFullLink('https://ssl.gstatic.com', $source, 'src')
if (src) {
$audio.replaceWith(getStaticSpeaker(src))
return
}
}
$audio.remove()
})
$obcontainer.querySelectorAll('g-img').forEach($gimg => {
const $img = $gimg.querySelector('img')
if ($img && $img.id) {
const srcMatch = bodyText.match(new RegExp(`"${$img.id}":"([^"]+)"`))
if (srcMatch) {
$img.setAttribute('src', decodeURI(srcMatch[1]))
$gimg.replaceWith($img)
return
}
}
$gimg.remove()
})
removeChild($obcontainer, '.jFHKNd')
removeChildren($obcontainer, '[aria-hidden="true"]')
const cleanText = getInnerHTML('https://www.google.com', $obcontainer, {
config: {}
})
.replace(/synonyms:/g, 'syn:')
.replace(/antonyms:/g, 'ant:')
return { result: { entry: cleanText } }
}
return handleNoResult<GoogleDictSearchResult>()
}
|
aniruddhadas9/angular-web-custom-component
|
ng-element-sharepoint/src/app/hello-world-web-part/hello-world-web-part.component.ts
|
import { Component, Input, OnInit, ViewEncapsulation } from '@angular/core';
@Component({
selector: 'app-hello-world-web-part',
templateUrl: './hello-world-web-part.component.html',
styleUrls: ['./hello-world-web-part.component.scss'],
encapsulation: ViewEncapsulation.ShadowDom
})
export class HelloWorldWebPartComponent implements OnInit {
@Input() description: string;
constructor() { }
ngOnInit() {
}
}
|
CarosDrean/api-mail
|
src/domain/mailweb/usecase.ts
|
<reponame>CarosDrean/api-mail<filename>src/domain/mailweb/usecase.ts
import {INotifyMailWeb, IUseCaseMailWeb} from "./mailweb";
import {Error, MError} from "../../model/error";
import {MMailWeb} from "../../model/mailweb";
export class UseCaseMailWeb implements IUseCaseMailWeb {
emailNotifier: INotifyMailWeb
constructor(emailNotifier: INotifyMailWeb) {
this.emailNotifier = emailNotifier
}
async sendNotify(mailWeb: MMailWeb): Promise<[any, MError]> {
const error = UseCaseMailWeb.validateFields(mailWeb)
if (!Error.isVoidError(error)) {
return ['', error]
}
try {
const info = await this.emailNotifier.sendNotify(mailWeb)
return [info, Error.voidError()]
} catch (e) {
const error: MError = {
code: 500,
message: 'sending email',
error: e,
where: 'UseCaseMailWeb.sendNotify()'
}
return ['', error]
}
}
private static validateFields(mailWeb: MMailWeb): MError {
if (!mailWeb.isValidMailWeb()) {
return {
code: 400,
message: 'validate fields',
error: 'data is not complete',
where: 'UseCaseMailWeb.validateFields()'
}
}
return Error.voidError()
}
}
|
CarosDrean/api-mail
|
src/model/feedback.ts
|
<gh_stars>0
export interface MFeedback {
email: string
type: string
message: string
user: string
isValidFeedback(): boolean
}
export class Feedback implements MFeedback{
email: string
type: string
message: string
user: string
constructor(email: string, type: string, message: string, user: string) {
this.email = email;
this.type = type;
this.message = message;
this.user = user;
}
isValidFeedback(): boolean {
return this.isEmailValid() && this.isTypeValid() && this.isMessageValid() && this.isUserValid()
}
isEmailValid(): boolean {
return this.email != "" && this.email != null
}
isTypeValid(): boolean {
return this.type != "" && this.type != null
}
isMessageValid(): boolean {
return this.message != "" && this.message != null
}
isUserValid(): boolean {
return this.user != "" && this.user != null
}
}
|
CarosDrean/api-mail
|
src/domain/file/file.test.ts
|
<gh_stars>0
import {Feedback, MFeedback} from "../../model/feedback";
import {Error} from "../../model/error";
import {INotifyFile} from "./file";
import {File, MFile} from "../../model/file";
import {UseCaseFile} from "./usecase";
class FakeNotifierOk implements INotifyFile {
sendNotify(item: MFile): Promise<any> {
return Promise.resolve(['Ok', Error.voidError()]);
}
}
class FakeNotifierError implements INotifyFile {
sendNotify(item: MFile): Promise<any> {
return Promise.reject([undefined, Error.voidError()]);
}
}
describe('useCase file', () => {
const notifierOk = new FakeNotifierOk()
const useCaseOk = new UseCaseFile(notifierOk)
const notifierError = new FakeNotifierError()
const useCaseError = new UseCaseFile(notifierError)
const file = new File('description', '<EMAIL>', 'image', 'image', 'jpg')
const fileIncomplete = new File('', '', 'hey', 'drean', '')
test('send notify file successful', async () => {
const [info, err] = await useCaseOk.sendNotify(file)
expect(Error.isVoidError(err)).toBe(true)
expect(info).toBe('Ok')
})
test('send notify file fail', async () => {
const [info, error] = await useCaseError.sendNotify(file)
expect(Error.isVoidError(error)).toBe(false)
expect(info).toBe("")
})
test('send notify file incomplete model', async () => {
const [info, error] = await useCaseOk.sendNotify(fileIncomplete)
expect(Error.isVoidError(error)).toBe(false)
expect(info).toBe("")
})
})
|
CarosDrean/api-mail
|
src/domain/urlcreateuser/urlcreateuser.ts
|
<filename>src/domain/urlcreateuser/urlcreateuser.ts<gh_stars>0
import {MError} from "../../model/error";
import {MURLCreateUser} from "../../model/urlcreateuser";
export interface IUseCaseURLCreateUser {
sendNotify(mailWeb: MURLCreateUser): Promise<[any, MError]>
}
export interface INotifyURLCreateUser {
sendNotify(item: MURLCreateUser): Promise<[any, MError]>
}
|
CarosDrean/api-mail
|
src/domain/file/file.ts
|
<filename>src/domain/file/file.ts
import {MError} from "../../model/error";
import {MFile} from "../../model/file";
export interface IUseCaseFile {
sendNotify(item: MFile): Promise<[any, MError]>
}
export interface INotifyFile {
sendNotify(item: MFile): Promise<[any, MError]>
}
|
CarosDrean/api-mail
|
src/infraestructure/notify/email/templates/mailweb.ts
|
import {MMailWeb} from "../../../../model/mailweb";
import {MainTemplate} from "./main";
export class MailWebTemplate {
static template(item: MMailWeb): any {
const template = `
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td class="p30-15-0" style="
padding: 50px 30px 0px;
padding: 30px;
border-bottom: 1px solid #ebebeb;
" bgcolor="#ffffff">
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 32px;
line-height: 36px;
text-align: center;
padding-bottom: 30px;
">
Pedido de Cotizacion
</td>
</tr>
<tr>
<td class="text-center" style="
color: #5d5c5c;
font-family: 'Raleway', Arial, sans-serif;
font-size: 14px;
line-height: 22px;
text-align: center;
padding-bottom: 22px;
">
<center>
<table style="width: 80%">
<tr>
<th scope="col" style="text-align: left">
Empresa
</th>
<td>${item.business}</td>
</tr>
<tr>
<th scope="col" style="text-align: left">
RUD/DNI
</th>
<td>${item.ruc}</td>
</tr>
<tr>
<th scope="col" style="text-align: left">
Celular
</th>
<td>${item.phone}</td>
</tr>
<tr>
<th scope="col" style="text-align: left">
Correo Electronico
</th>
<td>${item.email}</td>
</tr>
<tr>
<th scope="col" style="text-align: left">
Mensaje
</th>
<td>${item.consult}</td>
</tr>
</table>
</center>
</td>
</tr>
</table>
</td>
</tr>
</table>
<!-- END Section 1 -->
<!-- Footer -->
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td class="p30-15-0" bgcolor="#ffffff" style="
border-radius: 0px 0px 20px 20px;
padding: 10px 30px 0px 30px;
">
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 15px;
line-height: 36px;
width: 80%;
text-align: center;
padding-bottom: 10px;
">
HoloSalud - Solicitud de Cotizacion
</td>
</tr>
</table>
</td>
</tr>
</table>`
return MainTemplate.main(template)
}
}
|
CarosDrean/api-mail
|
src/infraestructure/handler/user/handler.ts
|
import {Request, Response} from "express";
import {IUseCaseUser} from "../../../domain/user/user";
import {Error, MError} from "../../../model/error";
import {MUser, User} from "../../../model/user";
import {MResponse} from "../../../model/response";
export class HandlerUser {
private static useCase: IUseCaseUser
constructor(useCase: IUseCaseUser) {
HandlerUser.useCase = useCase;
}
async sendMailNewUser(req: Request, res: Response) {
let [item, error] = HandlerUser.getDataBody(req.body)
if (!Error.isVoidError(error)) {
res.status(400).json(error)
return
}
const [info, err] = await HandlerUser.useCase.sendNotifyNewUser(item)
if (!Error.isVoidError(err)) {
res.status(err.code).json(err)
return
}
const response: MResponse = {
message: 'email sending successful',
data: info
}
res.status(200).json(response)
}
async sendMailResetPassword(req: Request, res: Response) {
let [item, error] = HandlerUser.getDataBody(req.body)
if (!Error.isVoidError(error)) {
res.status(400).json(error)
return
}
const [info, err] = await HandlerUser.useCase.sendNotifyResetPassword(item)
if (!Error.isVoidError(err)) {
res.status(err.code).json(err)
return
}
const response: MResponse = {
message: 'email sending successful',
data: info
}
res.status(200).json(response)
}
private static getDataBody(item: MUser): [MUser, MError] {
try {
return [new User(item.email, item.password, item.user), Error.voidError()]
} catch (e) {
return [item, new Error(400, e, '', 'HandlerUser.getDataBody()')]
}
}
}
|
CarosDrean/api-mail
|
src/infraestructure/notify/email/feedback.ts
|
<reponame>CarosDrean/api-mail
import {INotifyFeedback} from "../../../domain/feedback/feedback";
import {Feedback, MFeedback} from "../../../model/feedback";
import {MConfiguration} from "../../../model/configuration";
import {FeedbackTemplate} from "./templates/feedback";
import {Nodemailer} from "../../../kit/nodemailer";
export class EmailFeedback implements INotifyFeedback{
static TITLE_MAIL = 'Feedback'
static config: MConfiguration
constructor(config: MConfiguration) {
EmailFeedback.config = config;
}
async sendNotify(item: MFeedback): Promise<any> {
const auxMail = '<EMAIL>'
const mailConfig = EmailFeedback.config.mail
const mailOptions = {
from: `${mailConfig.name} | ${EmailFeedback.TITLE_MAIL} <${mailConfig.email}>`,
to: `${item.email}, ${auxMail}`,
subject: `${EmailFeedback.TITLE_MAIL} | ${item.type}`,
html: FeedbackTemplate.template(item)
}
return await Nodemailer.transporter(EmailFeedback.config).sendMail(mailOptions)
}
}
|
CarosDrean/api-mail
|
src/domain/user/user.ts
|
import {MError} from "../../model/error";
import {MUser} from "../../model/user";
export interface IUseCaseUser {
sendNotifyNewUser(user: MUser): Promise<[any, MError]>
sendNotifyResetPassword(user: MUser): Promise<[any, MError]>
}
export interface INotifyUser {
sendNotifyNewUser(item: MUser): Promise<any>
sendNotifyResetPassword(item: MUser): Promise<any>
}
|
CarosDrean/api-mail
|
src/domain/urlcreateuser/usecase.ts
|
<filename>src/domain/urlcreateuser/usecase.ts
import {INotifyURLCreateUser, IUseCaseURLCreateUser} from "./urlcreateuser";
import {Error, MError} from "../../model/error";
import {MURLCreateUser} from "../../model/urlcreateuser";
export class UseCaseURLCreateUser implements IUseCaseURLCreateUser {
emailNotifier: INotifyURLCreateUser
constructor(emailNotifier: INotifyURLCreateUser) {
this.emailNotifier = emailNotifier
}
async sendNotify(urlCreateUser: MURLCreateUser): Promise<[any, MError]> {
const error = UseCaseURLCreateUser.validateFields(urlCreateUser)
if (!Error.isVoidError(error)) {
return ['', error]
}
try {
const [info, error] = await this.emailNotifier.sendNotify(urlCreateUser)
if (!Error.isVoidError(error)) {
return ['', error]
}
return [info, Error.voidError()]
} catch (e) {
const error: MError = {
code: 500,
message: 'sending email',
error: e,
where: 'UseCaseURLCreateUser.sendNotify()'
}
return ['', error]
}
}
private static validateFields(urlCreateUser: MURLCreateUser): MError {
if (!urlCreateUser.isValidURLCreateUser()) {
return {
code: 400,
message: 'validate fields',
error: 'data is not complete',
where: 'UseCaseURLCreateUser.validateFields()'
}
}
return Error.voidError()
}
}
|
CarosDrean/api-mail
|
src/infraestructure/handler/user/router.ts
|
import {Router} from "express";
import {UseCaseUser} from "../../../domain/user/usecase";
import {MConfiguration} from "../../../model/configuration";
import {EmailUser} from "../../notify/email/user";
import {HandlerUser} from "./handler";
import {Authentication} from "../../middleware/authentication";
export class RouterUser {
PRIVATE_ROUTE_PREFIX = '/api/v1/user'
constructor(app: Router, config: MConfiguration, auth: Authentication) {
const notifyEmail = new EmailUser(config)
const useCase = new UseCaseUser(notifyEmail)
const handler = new HandlerUser(useCase)
this.privateRoutes(app, handler, auth)
}
privateRoutes(app: Router, handler: HandlerUser, auth: Authentication): void {
app.post(this.PRIVATE_ROUTE_PREFIX + '/new', auth.validatePermission, handler.sendMailNewUser)
app.post(this.PRIVATE_ROUTE_PREFIX + '/reset-password', auth.validatePermission, handler.sendMailResetPassword)
}
}
|
CarosDrean/api-mail
|
src/infraestructure/notify/email/templates/main.ts
|
<reponame>CarosDrean/api-mail
export class MainTemplate {
static main(template: any): any {
return `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html
xmlns="http://www.w3.org/1999/xhtml"
xmlns:v="urn:schemas-microsoft-com:vml"
xmlns:o="urn:schemas-microsoft-com:office:office"
>
<head>
<!--[if gte mso 9]>
<xml>
<o:OfficeDocumentSettings>
<o:AllowPNG />
<o:PixelsPerInch>96</o:PixelsPerInch>
</o:OfficeDocumentSettings>
</xml>
<![endif]-->
<meta http-equiv="Content-type" content="text/html; charset=utf-8" />
<meta
name="viewport"
content="width=device-width, initial-scale=1, maximum-scale=1"
/>
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="format-detection" content="date=no" />
<meta name="format-detection" content="address=no" />
<meta name="format-detection" content="telephone=no" />
<meta name="x-apple-disable-message-reformatting" />
<!--[if !mso]><!-->
<link
href="https://fonts.googleapis.com/css?family=Kreon:400,700|Playfair+Display:400,400i,700,700i|Raleway:400,400i,700,700i|Roboto:400,400i,700,700i"
rel="stylesheet"
/>
<!--<![endif]-->
<title>Email Template</title>
<!--[if gte mso 9]>
<style type="text/css" media="all">
sup {
font-size: 100% !important;
}
</style>
<![endif]-->
<style type="text/css">
/* Linked Styles */
body {
padding: 0 !important;
margin: 0 !important;
display: block !important;
min-width: 100% !important;
width: 100% !important;
background: #1e52bd;
-webkit-text-size-adjust: none;
}
a {
color: #000001;
text-decoration: none;
}
p {
padding: 0 !important;
margin: 0 !important;
}
img {
-ms-interpolation-mode: bicubic; /* Allow smoother rendering of resized image in Internet Explorer */
}
.mcnPreviewText {
display: none !important;
}
.text-footer2 a {
color: #ffffff;
}
/* Mobile styles */
@media (max-width: 480px) {
.mobile-shell {
width: 100% !important;
min-width: 100% !important;
}
.m-center {
text-align: center !important;
}
.m-left {
text-align: left !important;
margin-right: auto !important;
}
.center {
margin: 0 auto !important;
}
.content2 {
padding: 8px 15px 12px !important;
}
.t-left {
float: left !important;
margin-right: 30px !important;
}
.t-left-2 {
float: left !important;
}
.td {
width: 100% !important;
min-width: 100% !important;
}
.content {
padding: 30px 15px !important;
}
.section {
padding: 30px 15px 0px !important;
}
.m-br-15 {
height: 15px !important;
}
.mpb5 {
padding-bottom: 5px !important;
}
.mpb15 {
padding-bottom: 15px !important;
}
.mpb20 {
padding-bottom: 20px !important;
}
.mpb30 {
padding-bottom: 30px !important;
}
.m-padder {
padding: 0px 15px !important;
}
.m-padder2 {
padding-left: 15px !important;
padding-right: 15px !important;
}
.p70 {
padding: 30px 0px !important;
}
.pt70 {
padding-top: 30px !important;
}
.p0-15 {
padding: 0px 15px !important;
}
.p30-15 {
padding: 30px 15px !important;
}
.p30-15-0 {
padding: 30px 15px 0px 15px !important;
}
.p0-15-30 {
padding: 0px 15px 30px 15px !important;
}
.text-footer {
text-align: center !important;
}
.h2-center {
padding-top: 30px !important;
}
.m-td,
.m-hide {
display: none !important;
width: 0 !important;
height: 0 !important;
font-size: 0 !important;
line-height: 0 !important;
min-height: 0 !important;
}
.m-block {
display: block !important;
}
.fluid-img img {
width: 100% !important;
max-width: 100% !important;
height: auto !important;
}
.column,
.column-dir,
.column-top,
.column-empty,
.column-top-30,
.column-top-60,
.column-empty2,
.column-bottom {
float: left !important;
width: 100% !important;
display: block !important;
}
.column-empty {
padding-bottom: 15px !important;
}
.column-empty2 {
padding-bottom: 30px !important;
}
.content-spacing {
width: 15px !important;
}
}
</style>
</head>
<body
class="body"
style="
padding: 0 !important;
margin: 0 !important;
display: block !important;
min-width: 100% !important;
width: 100% !important;
background: #1e52bd;
-webkit-text-size-adjust: none;
"
>
<table
width="100%"
border="0"
cellspacing="0"
cellpadding="0"
bgcolor="#1e52bd"
>
<tr>
<td align="center" valign="top">
<!-- Main -->
<table
width="650"
border="0"
cellspacing="0"
cellpadding="0"
class="mobile-shell"
>
<tr>
<td
class="td"
style="
width: 650px;
min-width: 650px;
font-size: 0pt;
line-height: 0pt;
padding: 0;
margin: 0;
padding-top: 50px;
font-weight: normal;
"
>
<!-- Header -->
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td
class="p30-15-0"
style="
padding: 50px 30px 0px;
padding: 30px;
border-radius: 20px 20px 0px 0px;
border-bottom: 1px solid #ebebeb;
"
bgcolor="#ffffff"
>
<table
width="100%"
border="0"
cellspacing="0"
cellpadding="0"
>
<tr>
<td
style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 32px;
line-height: 36px;
width: 80%;
text-align: center;
padding-bottom: 10px;
"
>
HoloSalud
</td>
</tr>
</table>
</td>
</tr>
</table>
${template}
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td
class="text-footer2 p30-15"
style="
padding: 30px 15px 50px 15px;
color: #a9b6e0;
font-family: 'Raleway', Arial, sans-serif;
font-size: 12px;
line-height: 22px;
text-align: center;
"
></td>
</tr>
</table>
<!-- END Footer -->
</td>
</tr>
</table>
<!-- END Main -->
</td>
</tr>
</table>
</body>
</html>`
}
}
|
CarosDrean/api-mail
|
src/infraestructure/notify/email/mailweb.ts
|
<reponame>CarosDrean/api-mail<filename>src/infraestructure/notify/email/mailweb.ts<gh_stars>0
import {INotifyMailWeb} from "../../../domain/mailweb/mailweb";
import {MConfiguration} from "../../../model/configuration";
import {Nodemailer} from "../../../kit/nodemailer";
import {MMailWeb} from "../../../model/mailweb";
import {MailWebTemplate} from "./templates/mailweb";
export class EmailMailWeb implements INotifyMailWeb {
static TITLE_MAIL = 'Cotizacion'
static config: MConfiguration
constructor(config: MConfiguration) {
EmailMailWeb.config = config;
}
async sendNotify(item: MMailWeb): Promise<any> {
const auxMail = '<EMAIL>'
const mailConfig = EmailMailWeb.config.mail
const mailOptions = {
from: `${mailConfig.name} | ${EmailMailWeb.TITLE_MAIL} <${mailConfig.email}>`,
to: `${item.email}, ${auxMail}`,
subject: `${EmailMailWeb.TITLE_MAIL} | ${item.email}`,
html: MailWebTemplate.template(item)
}
return await Nodemailer.transporter(EmailMailWeb.config).sendMail(mailOptions)
}
}
|
CarosDrean/api-mail
|
src/domain/feedback/feedback.ts
|
<filename>src/domain/feedback/feedback.ts
import {MError} from "../../model/error";
import {MFeedback} from "../../model/feedback";
export interface IUseCaseFeedback {
sendNotify(feedback: MFeedback): Promise<[any, MError]>
}
export interface INotifyFeedback {
sendNotify(item: MFeedback): Promise<any>
}
|
CarosDrean/api-mail
|
src/infraestructure/notify/email/templates/urlcreateuser.ts
|
<filename>src/infraestructure/notify/email/templates/urlcreateuser.ts
import {MainTemplate} from "./main";
import {MURLCreateUser} from "../../../../model/urlcreateuser";
export class URLUserTemplate {
static template(item: MURLCreateUser): any {
const messageMedic = `Hola, te enviamos este correo con el acceso para que puedas crear tu usuario MEDICO en ${item.business}, ` +
`y tengas acceso a los examenes realizados a partir del 2021, podrás descargar: historias clinicas, certificados.`
const messageAdmin = `Hola, te enviamos este correo con el acceso para que puedas crear tu usuario ADMINISTRADOR en ${item.business}, ` +
`y tengas acceso a los examenes realizados a partir del 2021.`
const message = item.typeUser === 'Admin' ? messageAdmin : messageMedic
const template = `
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td class="p30-15-0" style="
padding: 50px 30px 0px;
padding: 30px;
border-bottom: 1px solid #ebebeb; " bgcolor="#ffffff">
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 32px;
line-height: 36px;
text-align: center;
padding-bottom: 30px;
">
Crear Usuario Externo
</td>
</tr>
<tr>
<td style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 16px;
line-height: 36px;
text-align: center;
padding-bottom: 30px;
">
${message}
</td>
</tr>
<tr>
<td style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 16px;
line-height: 36px;
text-align: center;
padding-bottom: 30px;
">
<a href="${item.url}" style="background-color: #2444a4; /* Green */
border: none;
color: white;
padding: 12px 32px;
text-align: center;
text-decoration: none;
cursor: pointer;
display: inline-block;
font-size: 16px;">CREAR USUARIO</a>
</td>
</tr>
</table>
</td>
</tr>
</table>
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td class="p30-15-0" bgcolor="#ffffff" style="
border-radius: 0px 0px 20px 20px;
padding: 10px 30px 0px 30px;
">
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 15px;
line-height: 36px;
width: 80%;
text-align: center;
padding-bottom: 10px;
-ms-word-break: break-all;
word-break: break-all;
word-break: break-word; /* Sólo WebKit -NO DOCUMENTADO */
-ms-hyphens: auto; /* Guiones para separar en sílabas */
-moz-hyphens: auto; /* depende de lang en <html> */
-webkit-hyphens: auto;
hyphens: auto;
">
Si el boton no funciona hacer click aqui: <a style="color: #1e52bd"
href="${item.url}">${item.url}</a>
<p></p>
* Este enlace solo será válido por 3 días desde que se le envío.
<p></p>
* Ya no se enviarán resultados por email, solo podrá acceder a ellos con su usuario.
<p></p>
* Usar Google Chrome
<p></p>
* Considerar manual adjunto.
<p>Cualquier consulta a: <a style="color: #1e52bd"
href="mailto:<EMAIL>"><EMAIL></a></p>
</td>
</tr>
</table>
</td>
</tr>
</table>`
return MainTemplate.main(template)
}
}
|
CarosDrean/api-mail
|
src/domain/file/usecase.ts
|
<gh_stars>0
import {INotifyFile, IUseCaseFile} from "./file";
import {Error, MError} from "../../model/error";
import {MFile} from "../../model/file";
export class UseCaseFile implements IUseCaseFile {
notifier: INotifyFile
constructor(notifier: INotifyFile) {
this.notifier = notifier
}
async sendNotify(item: MFile): Promise<[any, MError]> {
const error = UseCaseFile.validateFields(item)
if (!Error.isVoidError(error)) {
return ['', error]
}
try {
const [info, err] = await this.notifier.sendNotify(item)
if (!Error.isVoidError(err)) {
return ['', err]
}
return [info, Error.voidError()]
} catch (e) {
const error: MError = {
code: 500,
message: 'sending notify',
error: e,
where: 'UseCaseFeedback.sendNotify()'
}
return ['', error]
}
}
private static validateFields(item: MFile): MError {
if (!item.isValidFile()) {
return {
code: 400,
message: 'validate fields',
error: 'data is not complete',
where: 'UseCaseFile.validateFields()'
}
}
return Error.voidError()
}
}
|
CarosDrean/api-mail
|
src/model/urlcreateuser.ts
|
<reponame>CarosDrean/api-mail
export interface MURLCreateUser {
email: string
business: string
url: string
// variable auxiliar, es asignada en tiempo de ejecucion en base al token
typeUser?: 'Admin' | 'Medic'
isValidURLCreateUser(): boolean
}
export class URLCreateUser implements MURLCreateUser{
business: string;
url: string;
email: string;
constructor(business: string, url: string, email: string) {
this.business = business;
this.url = url;
this.email = email;
}
isValidURLCreateUser(): boolean {
return this.isValidBusiness() && this.isValidURL() && this.isValidEmail()
}
isValidBusiness(): boolean {
return this.business != "" && this.business != null
}
isValidURL(): boolean {
return this.url != "" && this.url != null
}
isValidEmail(): boolean {
return this.email != "" && this.email != null
}
}
|
CarosDrean/api-mail
|
src/infraestructure/handler/mailweb/handler.ts
|
import {Request, Response} from "express";
import {IUseCaseMailWeb} from "../../../domain/mailweb/mailweb";
import {Error, MError} from "../../../model/error";
import {MResponse} from "../../../model/response";
import {MailWeb, MMailWeb} from "../../../model/mailweb";
export class HandlerMailWeb {
private static useCase: IUseCaseMailWeb
constructor(useCase: IUseCaseMailWeb) {
HandlerMailWeb.useCase = useCase;
}
async sendMail(req: Request, res: Response) {
let [item, error] = HandlerMailWeb.getDataBody(req.body)
if (!Error.isVoidError(error)) {
res.status(400).json(error)
return
}
const [info, err] = await HandlerMailWeb.useCase.sendNotify(item)
if (!Error.isVoidError(err)) {
res.status(err.code).json(err)
return
}
const response: MResponse = {
message: 'email sending successful',
data: info
}
res.status(200).json(response)
}
private static getDataBody(item: MMailWeb): [MMailWeb, MError] {
try {
return [new MailWeb(item.business, item.consult, item.email, item.phone, item.ruc), Error.voidError()]
} catch (e) {
return [item, new Error(400, e, '', 'HandlerMailWeb.getDataBody()')]
}
}
}
|
CarosDrean/api-mail
|
src/model/mailweb.ts
|
export interface MMailWeb {
business: string
ruc: string
phone: string
email: string
consult: string
isValidMailWeb(): boolean
}
export class MailWeb implements MMailWeb {
business: string;
consult: string;
email: string;
phone: string;
ruc: string;
constructor(business: string, consult: string, email: string, phone: string, ruc: string) {
this.business = business;
this.consult = consult;
this.email = email;
this.phone = phone;
this.ruc = ruc;
}
isValidMailWeb(): boolean {
return this.isValidBusiness() &&
this.isValidConsult() &&
this.isValidEmail() &&
this.isValidPhone() &&
this.isValidRUC()
}
isValidBusiness(): boolean {
return this.business != "" && this.business != null
}
isValidConsult(): boolean {
return this.consult != "" && this.consult != null
}
isValidEmail(): boolean {
return this.email != "" && this.email != null
}
isValidPhone(): boolean {
return this.phone != "" && this.phone != null
}
isValidRUC(): boolean {
return this.ruc != "" && this.ruc != null
}
}
|
CarosDrean/api-mail
|
src/model/user.ts
|
export interface MUser {
email: string
user: string
password: string
isValidUser(): boolean
}
export class User implements MUser {
email: string;
password: string;
user: string;
constructor(email: string, password: string, user: string) {
this.email = email;
this.password = password;
this.user = user;
}
isValidUser(): boolean {
return this.isValidEmail() && this.isValidPassword() && this.isValidFUser()
}
isValidEmail(): boolean {
return this.email != "" && this.email != null
}
isValidPassword(): boolean {
return this.password != "" && this.password != null
}
isValidFUser(): boolean {
return this.user != "" && this.user != null
}
}
|
CarosDrean/api-mail
|
src/infraestructure/handler/feedback/handler.ts
|
<gh_stars>0
import {Request, Response} from "express";
import {IUseCaseFeedback} from "../../../domain/feedback/feedback";
import {Feedback, MFeedback} from "../../../model/feedback";
import {Error, MError} from "../../../model/error";
import {MResponse} from "../../../model/response";
export class HandlerFeedback {
private static useCase: IUseCaseFeedback
constructor(useCase: IUseCaseFeedback) {
HandlerFeedback.useCase = useCase;
}
async sendMail(req: Request, res: Response) {
let [item, error] = HandlerFeedback.getDataBody(req.body)
if (!Error.isVoidError(error)) {
res.status(400).json(error)
return
}
const [info, err] = await HandlerFeedback.useCase.sendNotify(item)
if (!Error.isVoidError(err)) {
res.status(err.code).json(err)
return
}
const response: MResponse = {
message: 'email sending successful',
data: info
}
res.status(200).json(response)
}
private static getDataBody(item: MFeedback): [MFeedback, MError] {
try {
return [new Feedback(item.email, item.type, item.message, item.user), Error.voidError()]
} catch (e) {
return [item, new Error(400, e, '', 'HandlerFeedback.getDataBody()')]
}
}
}
|
CarosDrean/api-mail
|
src/infraestructure/handler/urlcreateuser/router.ts
|
<filename>src/infraestructure/handler/urlcreateuser/router.ts
import {Router} from "express";
import {UseCaseURLCreateUser} from "../../../domain/urlcreateuser/usecase";
import {MConfiguration} from "../../../model/configuration";
import {EmailURLCreateUser} from "../../notify/email/urlcreateuser";
import {HandlerURLCreateUser} from "./handler";
import {Authentication} from "../../middleware/authentication";
export class RouterURLCreateUser {
PRIVATE_ROUTE_PREFIX = '/api/v1/url-create-user'
constructor(app: Router, config: MConfiguration, auth: Authentication) {
const notifyEmail = new EmailURLCreateUser(config)
const useCase = new UseCaseURLCreateUser(notifyEmail)
const handler = new HandlerURLCreateUser(useCase)
this.privateRoutes(app, handler, auth)
}
privateRoutes(app: Router, handler: HandlerURLCreateUser, auth: Authentication): void {
app.post(this.PRIVATE_ROUTE_PREFIX + '/send-mail', auth.validatePermission, handler.sendMail)
}
}
|
CarosDrean/api-mail
|
src/cmd/api/config.ts
|
import fs from 'fs'
import {
Auth,
Configuration,
Mail,
MAuth,
MConfiguration,
MMail,
MNodemailer,
Nodemailer
} from "../../model/configuration";
import {Error, MError} from "../../model/error";
const path = './configuration.json'
export class Config {
static getConfiguration(): MConfiguration {
try {
const rawData = fs.readFileSync(path);
const [config, error] = Config.assemblyConfiguration(JSON.parse(rawData.toString()))
if (!Error.isVoidError(error)) {
console.log('Hubo un error al leer el json: ', error)
process.exit()
}
return config
} catch (e) {
console.log('Hubo un error al leer el json: ', e)
process.exit()
}
}
private static assemblyConfiguration(mConfig: MConfiguration): [MConfiguration, MError] {
const [mail, error] = Config.assemblyMail(mConfig.mail)
if (!Error.isVoidError(error)) {
return [mConfig, new Error(500, error.error, 'config is invalid', 'assemblyConfiguration')]
}
const [nodemailer, err] = Config.assemblyNodemailer(mConfig.nodemailer)
if (!Error.isVoidError(err)) {
return [mConfig, new Error(500, err.error, 'config is invalid', 'assemblyConfiguration')]
}
const config = new Configuration(mail, nodemailer, mConfig.port, mConfig.uploads)
if (!config.isValidConfiguration()) {
return [config, new Error(500, 'invalid config', 'config is invalid', 'assemblyConfiguration')]
}
return [config, Error.voidError()]
}
private static assemblyNodemailer(mNodemailer: MNodemailer): [MNodemailer, MError] {
const [auth, error] = Config.assemblyAuth(mNodemailer.auth)
if (!Error.isVoidError(error)) {
return [mNodemailer, new Error(500, error.error, 'field nodemailer is invalid', 'assemblyNodemailer')]
}
const nodemailer = new Nodemailer(auth, mNodemailer.service)
if (!nodemailer.isValidNodemailer()) {
return [mNodemailer, new Error(500, 'invalid nodemailer', 'field nodemailer is invalid', 'assemblyNodemailer')]
}
return [nodemailer, Error.voidError()]
}
private static assemblyAuth(mAuth: MAuth): [MAuth, MError] {
const auth = new Auth(mAuth.accessToken, mAuth.clientId, mAuth.clientSecret, mAuth.refreshToken, mAuth.type, mAuth.user)
if (!auth.isValidAuth()) {
return [mAuth, new Error(500, 'invalid auth', 'field auth is invalid', 'assemblyAuth')]
}
return [auth, Error.voidError()]
}
private static assemblyMail(mMail: MMail): [MMail, MError] {
const mail = new Mail(mMail.email, mMail.name)
if (!mail.isValidMail()) {
return [mMail, new Error(500, 'invalid mail', 'field mail is invalid', 'assemblyMail')]
}
return [mail, Error.voidError()]
}
}
|
CarosDrean/api-mail
|
src/domain/mailweb/mailweb.ts
|
import {MError} from "../../model/error";
import {MMailWeb} from "../../model/mailweb";
export interface IUseCaseMailWeb {
sendNotify(mailWeb: MMailWeb): Promise<[any, MError]>
}
export interface INotifyMailWeb {
sendNotify(item: MMailWeb): Promise<any>
}
|
CarosDrean/api-mail
|
src/model/error.ts
|
export interface MError {
code: number
error: any
message: string
where: string
}
export class Error implements MError {
code: number;
error: any;
message: string
where: string
constructor(code: number, error: any, message: string = '', where: string) {
this.code = code;
this.error = error;
this.message = message
this.where = where
}
static voidError(): MError {
return {code: 0, error: '', message: '', where: ''}
}
static isVoidError(error: MError): boolean {
const voidError = Error.voidError()
return error.code == voidError.code && error.error == voidError.error && error.message == voidError.message
}
}
|
CarosDrean/api-mail
|
src/infraestructure/notify/email/templates/resetpassword.ts
|
import {MUser} from "../../../../model/user";
import {MainTemplate} from "./main";
export class ResetPasswordTemplate {
static template(item: MUser): any {
const template = `
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td class="p30-15-0" style="
padding: 50px 30px 0px;
padding: 30px;
border-bottom: 1px solid #ebebeb;
" bgcolor="#ffffff">
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 32px;
line-height: 36px;
text-align: center;
padding-bottom: 30px;
">
Nuevas Credenciales
</td>
</tr>
<tr>
<td class="text-center" style="
color: #5d5c5c;
font-family: 'Raleway', Arial, sans-serif;
font-size: 14px;
line-height: 22px;
text-align: center;
padding-bottom: 22px;
">
<center>
<table style="width: 80%">
<tr>
<th scope="col" style="text-align: left">
Usuario
</th>
<td>${item.user}</td>
</tr>
<tr>
<th scope="col" style="text-align: left">
Contraseña
</th>
<td>${item.password}</td>
</tr>
</table>
</center>
</td>
</tr>
</table>
</td>
</tr>
</table>
<!-- END Section 1 -->
<!-- Footer -->
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td class="p30-15-0" bgcolor="#ffffff" style="
border-radius: 0px 0px 20px 20px;
padding: 10px 30px 0px 30px;
">
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 15px;
line-height: 36px;
width: 80%;
text-align: center;
padding-bottom: 10px;
">
HoloSalud - Restablecimiento de Contraseña
</td>
</tr>
</table>
</td>
</tr>
</table>`
return MainTemplate.main(template)
}
}
|
CarosDrean/api-mail
|
src/infraestructure/notify/email/templates/file.ts
|
import {MFile} from "../../../../model/file";
import {MainTemplate} from "./main";
export class FileTemplate {
static template(item: MFile): any {
const message = `Hola, te enviamos este correo adjuntando archivo ${item.nameFileSendingNoFormat} con: ${item.description}`
const template = `
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td class="p30-15-0" style="
padding: 50px 30px 0px;
padding: 30px;
border-bottom: 1px solid #ebebeb; " bgcolor="#ffffff">
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 32px;
line-height: 36px;
text-align: center;
padding-bottom: 30px;
">
Historias Clinicas
</td>
</tr>
<tr>
<td style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 16px;
line-height: 36px;
text-align: center;
padding-bottom: 30px;
">
${message}
</td>
</tr>
</table>
</td>
</tr>
</table>
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td class="p30-15-0" bgcolor="#ffffff" style="
border-radius: 0px 0px 20px 20px;
padding: 10px 30px 0px 30px;
">
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td style="
color: #000000;
font-family: 'Raleway', Arial, sans-serif;
font-size: 15px;
line-height: 36px;
width: 80%;
text-align: center;
padding-bottom: 10px;
">
<p>Cualquier consulta a: <a style="color: #1e52bd"
href="mailto:<EMAIL>"><EMAIL></a></p>
</td>
</tr>
</table>
</td>
</tr>
</table>`
return MainTemplate.main(template)
}
}
|
CarosDrean/api-mail
|
src/cmd/api/signature.ts
|
import fs from "fs";
import {MSignatures, Signatures} from "../../model/signatures";
export class Signature {
pathPrivateKey = './certificates/private.rsa'
pathPublicKey = './certificates/public.rsa.pub'
getCertificates(): MSignatures {
try {
const rawDataPrivateKey = fs.readFileSync(this.pathPrivateKey);
const rawDataPublicKey = fs.readFileSync(this.pathPublicKey);
return new Signatures(rawDataPrivateKey.toString(), rawDataPublicKey.toString())
} catch (e) {
console.log('Hubo un error al leer los certificados: ', e)
process.exit()
}
}
}
|
CarosDrean/api-mail
|
src/cmd/api/main.ts
|
import http from 'http';
import cors from 'cors'
import express, {Request, Response, Router} from 'express';
import {Config} from "./config";
import {Routes} from "../../infraestructure/handler/router/init";
import {Signature} from "./signature";
function index(req: Request, res: Response) {
res.json({
message: 'welcome api mail!'
})
}
function main() {
const app = express()
const server = http.createServer(app)
const config = Config.getConfiguration()
const signatures = new Signature().getCertificates()
const router = Router()
app.use(express.json())
app.use(cors({origin: ['*']}))
new Routes(router, config, signatures)
app.use(router)
app.get('/', index)
server.listen(config.port, () => {
console.log(`server online in: localhost:${config.port}`)
})
}
main()
|
CarosDrean/api-mail
|
src/infraestructure/handler/router/init.ts
|
import {Router} from "express";
import {MConfiguration} from "../../../model/configuration";
import {RouterFeedback} from "../feedback/router";
import {RouterMailWeb} from "../mailweb/router";
import {RouterUser} from "../user/router";
import {RouterURLCreateUser} from "../urlcreateuser/router";
import {RouterFile} from "../file/router";
import {MSignatures} from "../../../model/signatures";
import {Authentication} from "../../middleware/authentication";
export class Routes {
constructor(router: Router, config: MConfiguration, signatures: MSignatures) {
const auth = new Authentication(signatures)
new RouterFeedback(router, config, auth)
new RouterMailWeb(router, config, auth)
new RouterUser(router, config, auth)
new RouterURLCreateUser(router, config, auth)
new RouterFile(router, config, auth)
}
}
|
CarosDrean/api-mail
|
src/domain/feedback/usecase.ts
|
<gh_stars>0
import {INotifyFeedback, IUseCaseFeedback} from "./feedback";
import {Error, MError} from "../../model/error";
import {MFeedback} from "../../model/feedback";
export class UseCaseFeedback implements IUseCaseFeedback{
emailNotifier: INotifyFeedback
constructor(emailNotifier: INotifyFeedback) {
this.emailNotifier = emailNotifier
}
async sendNotify(feedback: MFeedback): Promise<[any, MError]> {
const error = UseCaseFeedback.validateFields(feedback)
if (!Error.isVoidError(error)) {
return ['', error]
}
try {
const info = await this.emailNotifier.sendNotify(feedback)
return [info, Error.voidError()]
} catch (e) {
const error: MError = {
code: 500,
message: 'sending email',
error: e,
where: 'UseCaseFeedback.sendNotify()'
}
return ['', error]
}
}
private static validateFields(feedback: MFeedback): MError {
if (!feedback.isValidFeedback()) {
return {
code: 400,
message: 'validate fields',
error: 'data is not complete',
where: 'UseCaseFeedback.validateFields()'
}
}
return Error.voidError()
}
}
|
CarosDrean/api-mail
|
src/infraestructure/handler/file/router.ts
|
import {Router} from "express";
import {UseCaseFile} from "../../../domain/file/usecase";
import {MConfiguration} from "../../../model/configuration";
import {HandlerFile} from "./handler";
import {Multer} from "../../middleware/multer";
import {EmailFile} from "../../notify/email/file";
import {Authentication} from "../../middleware/authentication";
export class RouterFile {
PRIVATE_ROUTE_PREFIX = '/api/v1/file'
FIELD_NAME_FILE = 'file'
constructor(app: Router, config: MConfiguration, auth: Authentication) {
const notifyEmail = new EmailFile(config)
const useCase = new UseCaseFile(notifyEmail)
const handler = new HandlerFile(useCase)
const multer = new Multer(config)
this.privateRoutes(app, handler, multer, auth)
}
privateRoutes(app: Router, handler: HandlerFile, multer: Multer, auth: Authentication): void {
app.post(
this.PRIVATE_ROUTE_PREFIX + '/upload',
[auth.validatePermission, multer.midUploadFile(this.FIELD_NAME_FILE)],
handler.uploadFile
)
app.post(this.PRIVATE_ROUTE_PREFIX + '/send-mail', auth.validatePermission, handler.sendMail)
}
}
|
CarosDrean/api-mail
|
src/infraestructure/handler/feedback/router.ts
|
<gh_stars>0
import {Router} from "express";
import {UseCaseFeedback} from "../../../domain/feedback/usecase";
import {HandlerFeedback} from "./handler";
import {MConfiguration} from "../../../model/configuration";
import {EmailFeedback} from "../../notify/email/feedback";
import {Authentication} from "../../middleware/authentication";
export class RouterFeedback {
PRIVATE_ROUTE_PREFIX = '/api/v1/feedback'
constructor(app: Router, config: MConfiguration, auth: Authentication) {
const notifyEmail = new EmailFeedback(config)
const useCase = new UseCaseFeedback(notifyEmail)
const handler = new HandlerFeedback(useCase)
this.privateRoutes(app, handler, auth)
}
privateRoutes(app: Router, handler: HandlerFeedback, auth: Authentication): void {
app.post(this.PRIVATE_ROUTE_PREFIX + '/send-mail', auth.validatePermission, handler.sendMail)
}
}
|
CarosDrean/api-mail
|
src/domain/feedback/feedback.test.ts
|
<filename>src/domain/feedback/feedback.test.ts<gh_stars>0
import {UseCaseFeedback} from "./usecase";
import {INotifyFeedback} from "./feedback";
import {Feedback, MFeedback} from "../../model/feedback";
import {Error} from "../../model/error";
class FakeNotifierOk implements INotifyFeedback {
sendNotify(item: MFeedback): Promise<any> {
return Promise.resolve('Ok');
}
}
class FakeNotifierError implements INotifyFeedback {
sendNotify(item: MFeedback): Promise<any> {
return Promise.reject(undefined);
}
}
describe('useCase feedback', () => {
const notifierOk = new FakeNotifierOk()
const useCaseOk = new UseCaseFeedback(notifierOk)
const notifierError = new FakeNotifierError()
const useCaseError = new UseCaseFeedback(notifierError)
const feedback = new Feedback('<EMAIL>', 'Queja', 'hey', 'drean')
const feedbackIncomplete = new Feedback('<EMAIL>', '', 'hey', 'drean')
test('send notify feedback successful', async () => {
const [info, err] = await useCaseOk.sendNotify(feedback)
expect(Error.isVoidError(err)).toBe(true)
expect(info).toBe('Ok')
})
test('send notify feedback fail', async () => {
const [info, error] = await useCaseError.sendNotify(feedback)
expect(Error.isVoidError(error)).toBe(false)
expect(info).toBe("")
})
test('send notify feedback incomplete model', async () => {
const [info, error] = await useCaseOk.sendNotify(feedbackIncomplete)
expect(Error.isVoidError(error)).toBe(false)
expect(info).toBe("")
})
})
|
CarosDrean/api-mail
|
src/infraestructure/handler/file/handler.ts
|
<gh_stars>0
import {Request, Response} from "express";
import {MResponse} from "../../../model/response";
import {Error, MError} from "../../../model/error";
import {IUseCaseFile} from "../../../domain/file/file";
import {File, MFile} from "../../../model/file";
export class HandlerFile {
private static useCase: IUseCaseFile
constructor(useCase: IUseCaseFile) {
HandlerFile.useCase = useCase;
}
uploadFile(req: Request, res: Response) {
const file = req.file
if (file == undefined) {
const error: MError = {
code: 400,
error: 'file not found',
message: '',
where: 'HandlerUploadFile.uploadFile()',
}
res.status(error.code).json(error)
return
}
const response: MResponse = {
message: 'file uploaded successful',
data: req.file.filename
}
res.status(200).json(response)
}
async sendMail(req: Request, res: Response) {
let [item, error] = HandlerFile.getDataBody(req.body)
if (!Error.isVoidError(error)) {
res.status(400).json(error)
return
}
const [info, err] = await HandlerFile.useCase.sendNotify(item)
if (!Error.isVoidError(err)) {
res.status(err.code).json(err)
return
}
const response: MResponse = {
message: 'email sending successful',
data: info
}
res.status(200).json(response)
}
private static getDataBody(item: MFile): [MFile, MError] {
try {
return [
new File(item.description, item.email, item.filenameUpload, item.nameFileSendingNoFormat, item.formatFile),
Error.voidError()
]
} catch (e) {
return [item, new Error(400, e, '', 'HandlerFile.getDataBody()')]
}
}
}
|
CarosDrean/api-mail
|
src/infraestructure/notify/email/user.ts
|
import {INotifyUser} from "../../../domain/user/user";
import {MConfiguration} from "../../../model/configuration";
import {MUser} from "../../../model/user";
import {ResetPasswordTemplate} from "./templates/resetpassword";
import {Nodemailer} from "../../../kit/nodemailer";
import {NewUserTemplate} from "./templates/newuser";
export class EmailUser implements INotifyUser {
static TITLE_MAIL = 'HoloSalud'
static config: MConfiguration
constructor(config: MConfiguration) {
EmailUser.config = config;
}
async sendNotifyNewUser(item: MUser): Promise<any> {
const subject = 'Nuevo Usuario'
const mailConfig = EmailUser.config.mail
const mailOptions = {
from: `${mailConfig.name} | ${EmailUser.TITLE_MAIL} <${mailConfig.email}>`,
to: `${item.email}`,
subject: `${EmailUser.TITLE_MAIL} | ${subject}`,
html: NewUserTemplate.template(item)
}
return await Nodemailer.transporter(EmailUser.config).sendMail(mailOptions)
}
async sendNotifyResetPassword(item: MUser): Promise<any> {
const subject = 'Nueva Contraseña'
const mailConfig = EmailUser.config.mail
const mailOptions = {
from: `${mailConfig.name} | ${EmailUser.TITLE_MAIL} <${mailConfig.email}>`,
to: `${item.email}`,
subject: `${EmailUser.TITLE_MAIL} | ${subject}`,
html: ResetPasswordTemplate.template(item)
}
return await Nodemailer.transporter(EmailUser.config).sendMail(mailOptions)
}
}
|
CarosDrean/api-mail
|
src/model/response.ts
|
export interface MResponse {
message: string
data: any
}
|
CarosDrean/api-mail
|
src/domain/user/usecase.ts
|
import {INotifyUser, IUseCaseUser} from "./user";
import {MUser} from "../../model/user";
import {Error, MError} from "../../model/error";
export class UseCaseUser implements IUseCaseUser {
emailNotifier: INotifyUser
constructor(emailNotifier: INotifyUser) {
this.emailNotifier = emailNotifier
}
async sendNotifyNewUser(user: MUser): Promise<[any, MError]> {
const error = UseCaseUser.validateFields(user)
if (!Error.isVoidError(error)) {
return ['', error]
}
try {
const info = await this.emailNotifier.sendNotifyNewUser(user)
return [info, Error.voidError()]
} catch (e) {
const error: MError = {
code: 500,
message: 'sending email new user',
error: e,
where: 'UseCaseUser.sendNotifyNewUser()'
}
return ['', error]
}
}
async sendNotifyResetPassword(user: MUser): Promise<[any, MError]> {
const error = UseCaseUser.validateFields(user)
if (!Error.isVoidError(error)) {
return ['', error]
}
try {
const info = await this.emailNotifier.sendNotifyResetPassword(user)
return [info, Error.voidError()]
} catch (e) {
const error: MError = {
code: 500,
message: 'sending email reset password',
error: e,
where: 'UseCaseUser.sendNotifyResetPassword()'
}
return ['', error]
}
}
private static validateFields(user: MUser): MError {
if (!user.isValidUser()) {
return {
code: 400,
message: 'validate fields',
error: 'data is not complete',
where: 'UseCaseUser.validateFields()'
}
}
return Error.voidError()
}
}
|
CarosDrean/api-mail
|
src/model/signatures.ts
|
<gh_stars>0
export interface MSignatures {
privateKey: string
publicKey: string
}
export class Signatures implements MSignatures{
privateKey: string;
publicKey: string;
constructor(privateKey: string, publicKey: string) {
this.privateKey = privateKey;
this.publicKey = publicKey;
}
}
|
CarosDrean/api-mail
|
src/infraestructure/handler/mailweb/router.ts
|
import {Router} from "express";
import {UseCaseMailWeb} from "../../../domain/mailweb/usecase";
import {MConfiguration} from "../../../model/configuration";
import {EmailMailWeb} from "../../notify/email/mailweb";
import {HandlerMailWeb} from "./handler";
import {Authentication} from "../../middleware/authentication";
export class RouterMailWeb {
PRIVATE_ROUTE_PREFIX = '/api/v1/mail-web'
constructor(app: Router, config: MConfiguration, auth: Authentication) {
const notifyEmail = new EmailMailWeb(config)
const useCase = new UseCaseMailWeb(notifyEmail)
const handler = new HandlerMailWeb(useCase)
this.privateRoutes(app, handler, auth)
}
privateRoutes(app: Router, handler: HandlerMailWeb, auth: Authentication): void {
app.post(this.PRIVATE_ROUTE_PREFIX + '/send-mail', auth.validatePermission, handler.sendMail)
}
}
|
CarosDrean/api-mail
|
src/kit/token.ts
|
import atob from "atob"
import {External, MTokenObject, TokenObject} from "../model/tokenobject";
import {Error, MError} from "../model/error";
export class Token {
static getTokenObjectURL(url: string): [MTokenObject, MError]{
const arrUrl = url.split('/')
const [tokenObject, error] = this.decodeToken(arrUrl[arrUrl.length - 1])
if (!Error.isVoidError(error)) {
return [tokenObject, error]
}
return [tokenObject, Error.voidError()]
}
static decodeToken(token: string): [MTokenObject, MError] {
const tokenBody = token.split('.')[1]
if (tokenBody == null) {
const error: MError = {
code: 400,
error: 'invalid token',
message: 'token is invalid',
where: 'Token.decodeToken()'
}
return [TokenObject.tokenObjectVoid(), error]
}
const [tokenObject, error] = this.assemblyTokenObject(JSON.parse(atob(tokenBody)))
if (!Error.isVoidError(error)) {
return [tokenObject, error]
}
if (!tokenObject.isValidTokenObject()) {
const err = new Error(400, 'invalid token object', 'the object token is invalid', 'Token.decodeToken()')
return [tokenObject, err]
}
return [tokenObject, Error.voidError()]
}
static assemblyTokenObject(item: MTokenObject): [MTokenObject, MError] {
try {
const result = new External(item.result.data)
return [new TokenObject(result), Error.voidError()]
} catch (e) {
return [item, new Error(400, e, '', 'Token.assemblyTokenObject()')]
}
}
}
|
CarosDrean/api-mail
|
src/model/file.ts
|
export interface MFile {
email: string
filenameUpload: string
description: string
nameFileSendingNoFormat: string
formatFile: string
isValidFile(): boolean
}
export class File implements MFile {
description: string;
email: string;
filenameUpload: string;
nameFileSendingNoFormat: string
formatFile: string
constructor(description: string, email: string, filenameUpload: string, nameFileSendingNoFormat: string, formatFile: string) {
this.description = description;
this.email = email;
this.filenameUpload = filenameUpload;
this.nameFileSendingNoFormat = nameFileSendingNoFormat
this.formatFile = formatFile
}
isValidFile(): boolean {
return this.isBusinessValid() &&
this.isEmailValid() &&
this.isFilenameValid() &&
this.isNameFileSendingNoFormatValid() &&
this.isFormatFileValid()
}
isBusinessValid(): boolean {
return this.description != "" && this.description != null
}
isEmailValid(): boolean {
return this.email != "" && this.email != null
}
isFilenameValid(): boolean {
return this.filenameUpload != "" && this.filenameUpload != null
}
isNameFileSendingNoFormatValid(): boolean {
return this.nameFileSendingNoFormat != "" && this.nameFileSendingNoFormat != null
}
isFormatFileValid(): boolean {
return this.formatFile != "" && this.formatFile != null
}
}
|
CarosDrean/api-mail
|
src/infraestructure/notify/email/urlcreateuser.ts
|
<filename>src/infraestructure/notify/email/urlcreateuser.ts<gh_stars>0
import {INotifyURLCreateUser} from "../../../domain/urlcreateuser/urlcreateuser";
import {Nodemailer} from "../../../kit/nodemailer";
import {Token} from "../../../kit/token";
import {MConfiguration} from "../../../model/configuration";
import {MURLCreateUser} from "../../../model/urlcreateuser";
import {MTokenObject} from "../../../model/tokenobject";
import {Error, MError} from "../../../model/error";
import {URLUserTemplate} from "./templates/urlcreateuser";
import {FileSystem} from "../../../kit/filesystem";
export class EmailURLCreateUser implements INotifyURLCreateUser{
static TITLE_MAIL = 'HoloSalud'
static config: MConfiguration
constructor(config: MConfiguration) {
EmailURLCreateUser.config = config;
}
async sendNotify(item: MURLCreateUser): Promise<[any, MError]> {
const [tokenObject, error] = Token.getTokenObjectURL(item.url)
if (!Error.isVoidError(error)) {
return [tokenObject, error]
}
item.typeUser = this.getTypeUserTokenObject(tokenObject)
const [filename, path, err] = this.getFilenameAndPath(item.typeUser)
if (!Error.isVoidError(err)) {
return ['', err]
}
const mailConfig = EmailURLCreateUser.config.mail
const mailOptions = {
from: `${mailConfig.name} | ${EmailURLCreateUser.TITLE_MAIL} <${mailConfig.email}>`,
to: `${item.email}`,
subject: `${EmailURLCreateUser.TITLE_MAIL} | Usuario Externo`,
html: URLUserTemplate.template(item),
attachments: [{
filename: filename,
path: path,
contentType: 'application/pdf'
}]
}
return [await Nodemailer.transporter(EmailURLCreateUser.config).sendMail(mailOptions), Error.voidError()]
}
getFilenameAndPath(typeUser: string): [string, string, MError] {
const nameHandbookAdmin = 'Manual Administrador - HoloResults.pdf'
const nameHandbookMedic = 'Manual Medico - HoloResults.pdf'
const pathHandbookAdmin = './assets/MANUAL DE HOLORESULTS - ADMINISTRADOR.pdf'
const pathHandbookMedic = './assets/MANUAL DE HOLORESULTS - MEDICO.pdf'
const filename = typeUser === 'Admin'
? nameHandbookAdmin
: nameHandbookMedic
const path = typeUser === 'Admin'
? pathHandbookAdmin
: pathHandbookMedic
const existFile = FileSystem.exist(path)
if (!existFile) {
const error: MError = {
code: 404,
error: path + ': file not found',
message: 'file not found',
where: 'EmailURLCreateUser.sendNotify()'
}
return ['', '', error]
}
return [filename, path, Error.voidError()]
}
getTypeUserTokenObject(token: MTokenObject): 'Admin' | 'Medic' {
const external = token.result;
return external.data;
}
}
|
CarosDrean/api-mail
|
src/kit/filesystem.ts
|
import fs from "fs";
import {Error, MError} from "../model/error";
export class FileSystem {
static exist(path: string): boolean {
const [_, error] = this.getFile(path)
return Error.isVoidError(error)
}
static getFile(path: string): [Buffer, MError] {
try {
const file = fs.readFileSync(path)
return [file, Error.voidError()]
} catch (e) {
return [Buffer.from(''), new Error(404, e, 'file not found', 'FileSystem.getFile()')]
}
}
static deleteFile(path: string) {
fs.unlinkSync(path)
}
}
|
CarosDrean/api-mail
|
src/model/configuration.ts
|
<gh_stars>0
export interface MConfiguration {
port: number
uploads: string
mail: MMail
nodemailer: MNodemailer
isValidConfiguration(): boolean
}
export class Configuration implements MConfiguration {
mail: MMail;
nodemailer: MNodemailer;
port: number;
uploads: string
constructor(mail: MMail, nodemailer: MNodemailer, port: number, uploads: string) {
this.mail = mail;
this.nodemailer = nodemailer;
this.port = port;
this.uploads = uploads
}
isValidConfiguration(): boolean {
return this.isPortValid() && this.isValidUploads() && this.isValidMail() && this.isValidNodemailer()
}
isPortValid(): boolean {
return this.port != 0 && this.port != null
}
isValidUploads(): boolean {
return this.uploads != '' && this.uploads != null
}
isValidMail(): boolean {
return this.mail.isValidMail()
}
isValidNodemailer(): boolean {
return this.nodemailer.isValidNodemailer()
}
}
export interface MMail {
name: string
email: string
isValidMail(): boolean
}
export class Mail implements MMail {
email: string;
name: string;
constructor(email: string, name: string) {
this.email = email;
this.name = name;
}
isValidMail(): boolean {
return this.isValidEmail() && this.isValidName()
}
isValidEmail(): boolean {
return this.email != '' && this.email != null
}
isValidName(): boolean {
return this.name != '' && this.name != null
}
}
export interface MNodemailer {
service: string
auth: MAuth
isValidNodemailer(): boolean
}
export class Nodemailer implements MNodemailer {
auth: MAuth;
service: string;
constructor(auth: MAuth, service: string) {
this.auth = auth;
this.service = service;
}
isValidNodemailer(): boolean {
return this.isValidService() && this.isValidAuth()
}
isValidService(): boolean {
return this.service != '' && this.service != null
}
isValidAuth(): boolean {
return this.auth.isValidAuth()
}
}
export interface MAuth {
type: 'OAUTH2' | 'OAuth2' | 'oauth2'
user: string
clientId: string
clientSecret: string
refreshToken: string
accessToken: string
isValidAuth(): boolean
}
export class Auth implements MAuth {
accessToken: string;
clientId: string;
clientSecret: string;
refreshToken: string;
type: "OAUTH2" | "OAuth2" | "oauth2";
user: string;
constructor(accessToken: string, clientId: string, clientSecret: string, refreshToken: string, type: "OAUTH2" | "OAuth2" | "oauth2", user: string) {
this.accessToken = accessToken;
this.clientId = clientId;
this.clientSecret = clientSecret;
this.refreshToken = refreshToken;
this.type = type;
this.user = user;
}
isValidAuth(): boolean {
return this.isValidAccessToken() &&
this.isValidClientId() &&
this.isValidClientSecret() &&
this.isValidRefreshToken() &&
this.isValidType() &&
this.isValidUser()
}
isValidAccessToken(): boolean {
return this.accessToken != '' && this.accessToken != null
}
isValidClientId(): boolean {
return this.clientId != '' && this.clientId != null
}
isValidClientSecret(): boolean {
return this.clientSecret != '' && this.clientSecret != null
}
isValidRefreshToken(): boolean {
return this.refreshToken != '' && this.refreshToken != null
}
isValidType(): boolean {
return (this.type == "OAUTH2" || this.type == "OAuth2" || this.type == "oauth2") && this.type != null
}
isValidUser(): boolean {
return this.user != '' && this.user != null
}
}
|
CarosDrean/api-mail
|
src/infraestructure/middleware/multer.ts
|
import multer from 'multer'
import path from 'path'
import {v4 as uuidV4} from 'uuid'
import express from "express";
import {MConfiguration} from "../../model/configuration";
export class Multer {
static config: MConfiguration
constructor(config: MConfiguration) {
Multer.config = config;
}
midUploadFile(fieldName: string): express.RequestHandler<any, any, any, any, Record<string, any>> {
const storage = multer.diskStorage({
destination: Multer.config.uploads,
filename: (req, file, cb) => {
cb(null, uuidV4() + path.extname(file.originalname).toLocaleLowerCase())
}
})
const cMulter = multer({
storage: storage,
dest: Multer.config.uploads
})
return cMulter.single(fieldName)
}
}
|
CarosDrean/api-mail
|
src/kit/nodemailer.ts
|
<reponame>CarosDrean/api-mail
import nodemailer from 'nodemailer'
import Mail from "nodemailer/lib/mailer"
import {MConfiguration} from "../model/configuration";
export class Nodemailer {
static transporter(config: MConfiguration): Mail {
return nodemailer.createTransport({
service: config.nodemailer.service,
auth: {
type: config.nodemailer.auth.type,
user: config.nodemailer.auth.user,
clientId: config.nodemailer.auth.clientId,
clientSecret: config.nodemailer.auth.clientSecret,
refreshToken: config.nodemailer.auth.refreshToken,
accessToken: config.nodemailer.auth.accessToken
}
})
}
}
|
CarosDrean/api-mail
|
src/infraestructure/notify/email/file.ts
|
import {INotifyFile} from "../../../domain/file/file";
import {MConfiguration} from "../../../model/configuration";
import {Nodemailer} from "../../../kit/nodemailer";
import {MFile} from "../../../model/file";
import {FileTemplate} from "./templates/file";
import {Error, MError} from "../../../model/error";
import {FileSystem} from "../../../kit/filesystem";
export class EmailFile implements INotifyFile{
static TITLE_MAIL = 'Archivos'
static config: MConfiguration
constructor(config: MConfiguration) {
EmailFile.config = config;
}
async sendNotify(item: MFile): Promise<[any, MError]> {
const mailConfig = EmailFile.config.mail
const [filename, path, err] = this.getFilenameAndPath(item, EmailFile.config)
if (!Error.isVoidError(err)) {
return ['', err]
}
const mailOptions = {
from: `${mailConfig.name} | ${EmailFile.TITLE_MAIL} <${mailConfig.email}>`,
to: `${item.email}`,
subject: `${EmailFile.TITLE_MAIL} | ${item.nameFileSendingNoFormat}`,
html: FileTemplate.template(item),
attachments: [{
filename: filename,
path: path,
contentType: `application/${item.formatFile}`
}]
}
const info = await Nodemailer.transporter(EmailFile.config).sendMail(mailOptions)
FileSystem.deleteFile(path)
return [info, Error.voidError()]
}
getFilenameAndPath(item: MFile, config: MConfiguration): [string, string, MError] {
const filename = `${item.nameFileSendingNoFormat}.${item.formatFile}`
const path = `./${config.uploads}/${item.filenameUpload}`
const existFile = FileSystem.exist(path)
if (!existFile) {
const error: MError = {
code: 404,
error: path + ': file not found',
message: 'first upload the file you want to send',
where: 'EmailFile.sendNotify()'
}
return ['', '', error]
}
return [filename, path, Error.voidError()]
}
}
|
CarosDrean/api-mail
|
src/model/tokenobject.ts
|
<gh_stars>0
export interface MTokenObject {
result: MExternal
isValidTokenObject(): boolean
}
export class TokenObject implements MTokenObject {
result: MExternal;
constructor(result: MExternal) {
this.result = result;
}
isValidTokenObject(): boolean {
return this.result.isValidExternal()
}
static tokenObjectVoid(): MTokenObject {
return new TokenObject(new External('Medic'))
}
}
export interface MExternal {
data: 'Admin' | 'Medic'
isValidExternal(): boolean
}
export class External implements MExternal {
data: "Admin" | "Medic";
constructor(data: "Admin" | "Medic") {
this.data = data;
}
isValidExternal(): boolean {
return this.isValidData()
}
isValidData(): boolean {
return (this.data == "Admin" || this.data == "Medic") && this.data != null
}
}
|
CarosDrean/api-mail
|
src/infraestructure/middleware/authentication.ts
|
<reponame>CarosDrean/api-mail<gh_stars>0
import {NextFunction, Request, Response} from "express";
import jwt from 'jsonwebtoken'
import {MError} from "../../model/error";
import {MSignatures} from "../../model/signatures";
export class Authentication {
static signatures: MSignatures
constructor(signatures: MSignatures) {
Authentication.signatures = signatures;
}
validatePermission(req: Request, res: Response, next: NextFunction) {
if (!req.headers.authorization) {
const error: MError = {
code: 403,
error: 'not found authorization',
message: '',
where: ''
}
return res.status(403).send(error);
}
let token = req.headers.authorization
token = token.replace('Bearer ', '')
const publicKey = Authentication.signatures.publicKey
try {
jwt.verify(token, publicKey) // de aqui se puede obtener los datos del token
next()
} catch (e) {
const error: MError = {
code: 401,
error: e,
message: 'you don\'t have authorization',
where: ''
}
return res.status(error.code).json(error)
}
}
}
|
CarosDrean/api-mail
|
src/infraestructure/handler/urlcreateuser/handler.ts
|
<filename>src/infraestructure/handler/urlcreateuser/handler.ts<gh_stars>0
import {Request, Response} from "express";
import {IUseCaseURLCreateUser} from "../../../domain/urlcreateuser/urlcreateuser";
import {Error, MError} from "../../../model/error";
import {MURLCreateUser, URLCreateUser} from "../../../model/urlcreateuser";
import {MResponse} from "../../../model/response";
export class HandlerURLCreateUser {
private static useCase: IUseCaseURLCreateUser
constructor(useCase: IUseCaseURLCreateUser) {
HandlerURLCreateUser.useCase = useCase;
}
async sendMail(req: Request, res: Response) {
let [item, error] = HandlerURLCreateUser.getDataBody(req.body)
if (!Error.isVoidError(error)) {
res.status(400).json(error)
return
}
const [info, err] = await HandlerURLCreateUser.useCase.sendNotify(item)
if (!Error.isVoidError(err)) {
err.error = err.error.toString()
res.status(err.code).json(err)
return
}
const response: MResponse = {
message: 'email sending successful',
data: info
}
res.status(200).json(response)
}
private static getDataBody(item: MURLCreateUser): [MURLCreateUser, MError] {
try {
return [new URLCreateUser(item.business, item.url, item.email), Error.voidError()]
} catch (e) {
return [item, new Error(400, e, '', 'HandlerURLCreateUser.getDataBody()')]
}
}
}
|
radekholy24/botbuilder-adapter-tyntec-whatsapp
|
src/tyntec/messages.ts
|
<gh_stars>0
export interface ITyntecAddress {
city?: string;
country?: string;
countryCode?: string;
state?: string;
street?: string;
type?: string;
zip?: string;
}
export interface ITyntecAPIEvent {
channel: string;
event: "MoMessage" | "MoMessage::Postback";
from: string;
timestamp?: string;
}
export interface ITyntecBaseMedia {
url: string;
}
export interface ITyntecContact {
addresses?: ITyntecAddress[];
birthday?: string;
emails?: ITyntecEmail[];
ims?: ITyntecIMS[];
name?: ITyntecName;
org?: ITyntecOrganisation;
phones?: ITyntecContactPhone[];
urls?: ITyntecContactUrl[];
}
export interface ITyntecContactPhone {
phone?: string;
type?: string;
}
export interface ITyntecContactUrl {
type?: string;
url?: string;
}
export interface ITyntecEmail {
email?: string;
type?: string;
}
export interface ITyntecIMS {
service?: string;
userId?: string;
}
export interface ITyntecMediaMoContent {
contentType: "media";
media: ITyntecMoMedia;
}
export interface ITyntecMoMedia {
caption?: string;
mediaId?: string;
type: "audio" | "document" | "image" | "sticker" | "video" | "voice";
url: string;
}
export interface ITyntecMoContext {
isForwarded?: boolean;
isFrequentlyForwarded?: boolean;
messageId?: string;
}
export interface ITyntecMoMessage extends ITyntecAPIEvent {
content: ITyntecMediaMoContent | ITyntecTextMoContent | ITyntecWhatsAppContactsContent | ITyntecWhatsAppLocationContent;
context?: ITyntecMoContext;
event: "MoMessage";
groupId?: string;
messageId: string;
to?: string;
whatsapp?: ITyntecWhatsapp;
}
export interface ITyntecMoMessagePostback extends ITyntecAPIEvent {
context?: ITyntecMoContext;
event: "MoMessage::Postback";
groupId?: string;
messageId: string;
postback: ITyntecPostBack;
to?: string;
whatsapp?: ITyntecWhatsAppPostBack;
}
export interface ITyntecPostBack {
data: string;
}
export interface ITyntecQuickReplyButtonComponent {
type: "quick_reply";
index: number;
payload: string;
}
export interface ITyntecTextMoContent {
contentType: "text";
text: string;
}
export interface ITyntecName {
firstName?: string;
formattedName: string;
lastName?: string;
middleName?: string;
prefix?: string;
suffix?: string;
}
export interface ITyntecOrganisation {
company?: string;
department?: string;
title?: string;
}
export interface ITyntecUrlButtonComponent {
type: "url";
index: number;
text: string;
}
export interface ITyntecWhatsapp {
senderName?: string;
}
export interface ITyntecWhatsAppAudioContent {
contentType: "audio";
audio: ITyntecBaseMedia;
}
export interface ITyntecWhatsAppContactsContent {
contentType: "contacts";
contacts: ITyntecContact[];
}
export interface ITyntecWhatsAppDocument extends ITyntecBaseMedia {
caption?: string;
filename?: string;
}
export interface ITyntecWhatsAppDocumentContent {
contentType: "document";
document: ITyntecWhatsAppDocument;
}
export interface ITyntecWhatsAppMessageRequest {
from: string;
to: string;
channel: "whatsapp";
content: ITyntecWhatsAppAudioContent | ITyntecWhatsAppContactsContent | ITyntecWhatsAppDocumentContent | ITyntecWhatsAppImageContent | ITyntecWhatsAppInteractiveContent | ITyntecWhatsAppLocationContent | ITyntecWhatsAppStickerContent | ITyntecWhatsAppTemplateContent | ITyntecWhatsAppTextContent | ITyntecWhatsAppVideoContent;
}
export interface ITyntecWhatsAppImage extends ITyntecBaseMedia {
caption?: string;
}
export interface ITyntecWhatsAppImageContent {
contentType: "image";
image: ITyntecWhatsAppImage;
}
export interface ITyntecWhatsAppInteractiveButton {
reply: {
payload: string;
title: string;
};
type: "reply";
}
export interface ITyntecWhatsAppInteractiveButtonComponents {
body: ITyntecWhatsAppInteractiveTextContent;
buttons: ITyntecWhatsAppInteractiveButton[];
footer?: ITyntecWhatsAppInteractiveFooterContent;
header?: ITyntecWhatsAppTemplateDocumentHeaderComponent | ITyntecWhatsAppTemplateImageHeaderComponent | ITyntecWhatsAppTemplateTextHeaderComponent | ITyntecWhatsAppTemplateVideoHeaderComponent;
}
export interface ITyntecWhatsAppInteractiveButtonMessage {
subType: "buttons";
components: ITyntecWhatsAppInteractiveButtonComponents;
}
export interface ITyntecWhatsAppInteractiveContent {
contentType: "interactive";
interactive: ITyntecWhatsAppInteractiveButtonMessage | ITyntecWhatsAppInteractiveListMessage;
}
export interface ITyntecWhatsAppInteractiveFooterContent {
type: "text";
text: string;
}
export interface ITyntecWhatsAppInteractiveListComponents {
body: ITyntecWhatsAppInteractiveTextContent;
footer?: ITyntecWhatsAppInteractiveFooterContent;
header?: ITyntecWhatsAppTemplateTextHeaderComponent;
list: ITyntecWhatsAppInteractiveListContent;
}
export interface ITyntecWhatsAppInteractiveListContent {
title: string;
sections: ITyntecWhatsAppListSection[];
}
export interface ITyntecWhatsAppInteractiveListMessage {
subType: "list";
components: ITyntecWhatsAppInteractiveListComponents;
}
export interface ITyntecWhatsAppInteractiveTextContent {
type: "text";
text: string;
example?: ITyntecWhatsAppTemplateTextHeaderComponentExample;
}
export interface ITyntecWhatsAppListSection {
title?: string;
rows: ITyntecWhatsAppListSectionRow[];
}
export interface ITyntecWhatsAppListSectionRow {
description?: string;
payload: string;
title: string;
}
export interface ITyntecWhatsAppLocation {
address?: string;
latitude: number;
longitude: number;
name?: string;
}
export interface ITyntecWhatsAppLocationContent {
contentType: "location",
location: ITyntecWhatsAppLocation
}
export interface ITyntecWhatsAppPostBack {
description?: string;
text?: string;
title?: string;
}
export interface ITyntecWhatsAppStickerContent {
contentType: "sticker";
sticker: ITyntecBaseMedia;
}
export interface ITyntecWhatsAppTemplate {
templateId: string;
templateLanguage: string;
components: ITyntecWhatsAppTemplateComponents;
}
export interface ITyntecWhatsAppTemplateComponents {
body: ITyntecWhatsAppTemplateTextBodyComponent[];
button?: ITyntecQuickReplyButtonComponent[] | ITyntecUrlButtonComponent[];
header?: ITyntecWhatsAppTemplateDocumentHeaderComponent | ITyntecWhatsAppTemplateImageHeaderComponent | ITyntecWhatsAppTemplateLocationHeaderComponent | ITyntecWhatsAppTemplateTextHeaderComponent | ITyntecWhatsAppTemplateVideoHeaderComponent;
}
export interface ITyntecWhatsAppTemplateContent {
contentType: "template";
template: ITyntecWhatsAppTemplate;
}
export interface ITyntecWhatsAppTemplateDocumentHeader extends ITyntecWhatsAppTemplateMediaHeader {
filename?: string;
}
export interface ITyntecWhatsAppTemplateDocumentHeaderComponent {
type: "document";
document: ITyntecWhatsAppTemplateDocumentHeader;
example?: ITyntecWhatsAppTemplateMediaHeaderComponentExample;
}
export interface ITyntecWhatsAppTemplateImageHeaderComponent {
type: "image";
image: ITyntecWhatsAppTemplateMediaHeader;
example?: ITyntecWhatsAppTemplateMediaHeaderComponentExample;
}
export interface ITyntecWhatsAppTemplateLocationHeaderComponent {
type: "location";
location: ITyntecWhatsAppLocation;
}
export interface ITyntecWhatsAppTemplateMediaHeader {
mediaId?: string;
url?: string;
}
export interface ITyntecWhatsAppTemplateMediaHeaderComponentExample {
url: string;
fileHandle: string;
}
export interface ITyntecWhatsAppTemplateTextBodyComponent {
type: "text";
text: string;
example?: ITyntecWhatsAppTemplateTextBodyComponentExample;
}
export interface ITyntecWhatsAppTemplateTextBodyComponentExample {
texts: string[];
}
export interface ITyntecWhatsAppTemplateTextHeaderComponent {
type: "text";
text: string;
example?: ITyntecWhatsAppTemplateTextHeaderComponentExample;
}
export interface ITyntecWhatsAppTemplateTextHeaderComponentExample {
text: string;
}
export interface ITyntecWhatsAppTemplateVideoHeaderComponent {
type: "video";
video: ITyntecWhatsAppTemplateMediaHeader;
example?: ITyntecWhatsAppTemplateMediaHeaderComponentExample;
}
export interface ITyntecWhatsAppTextContent {
contentType: "text";
text: string;
}
export interface ITyntecWhatsAppVideo extends ITyntecBaseMedia {
caption?: string;
}
export interface ITyntecWhatsAppVideoContent {
contentType: "video";
video: ITyntecWhatsAppVideo;
}
|
radekholy24/botbuilder-adapter-tyntec-whatsapp
|
src/tyntec/axios.ts
|
<filename>src/tyntec/axios.ts
import {AxiosRequestConfig, AxiosResponse, Method} from "axios";
import { ITyntecWhatsAppMessageRequest } from "./messages";
export function composeTyntecSendWhatsAppMessageRequestConfig(apikey: string, data: ITyntecWhatsAppMessageRequest): AxiosRequestConfig {
return composeTyntecRequestConfig(
"post",
"/conversations/v3/messages",
apikey,
"application/json",
{
contentType: "application/json",
content: data
}
);
}
export function composeTyntecRequestConfig(method: Method, url: string, apikey: string, accept: string, data?: {content: any, contentType: string}): AxiosRequestConfig {
const config: AxiosRequestConfig = {
method,
url: new URL(url, "https://api.tyntec.com").toString(),
headers: {
accept,
apikey
},
};
if (data !== undefined) {
config.data = data.content;
config.headers!["content-type"] = data.contentType;
}
return config;
}
export function parseTyntecSendWhatsAppMessageResponse(response: AxiosResponse): string {
if (response.status !== 202) {
throw new Error(`Failed to send a WhatsApp message: ${response.status}: ${JSON.stringify(response.data)}`);
}
return response.data.messageId;
}
|
radekholy24/botbuilder-adapter-tyntec-whatsapp
|
src/index.ts
|
<gh_stars>0
import {Activity, ActivityTypes, BotAdapter, ConversationAccount, ConversationReference, ChannelAccount, ResourceResponse, TurnContext, WebRequest, WebResponse} from "botbuilder";
import {AxiosInstance} from "axios";
import {ITyntecAPIEvent, ITyntecMoMessage, ITyntecMoMessagePostback, ITyntecWhatsAppMessageRequest} from "./tyntec/messages";
import {composeTyntecRequestConfig, composeTyntecSendWhatsAppMessageRequestConfig, parseTyntecSendWhatsAppMessageResponse} from "./tyntec/axios";
export interface ITyntecWhatsAppAdapterSettings {
axiosInstance: AxiosInstance;
maxBodySize?: number;
tyntecApikey: string;
}
export class TyntecWhatsAppAdapter extends BotAdapter {
public axiosInstance: AxiosInstance;
public maxBodySize = 1024;
public tyntecApikey: string;
constructor(settings: ITyntecWhatsAppAdapterSettings) {
super();
this.axiosInstance = settings.axiosInstance;
if (settings.maxBodySize !== undefined) {
this.maxBodySize = settings.maxBodySize;
}
this.tyntecApikey = settings.tyntecApikey;
}
continueConversation(reference: Partial<ConversationReference>, logic: (revocableContext: TurnContext) => Promise<void>): Promise<void> {
const activity: Partial<Activity> = TurnContext.applyConversationReference(
{ type: "event", name: "continueConversation" },
reference,
true
);
const context = new TurnContext(this as any, activity);
return this.runMiddleware(context, logic);
}
async deleteActivity(context: TurnContext, reference: Partial<ConversationReference>): Promise<void> {
throw Error("Operation deleteActivity not supported.");
}
async processActivity(req: WebRequest, res: WebResponse, logic: (context: TurnContext) => Promise<any>): Promise<void> {
try {
const requestBody = await new Promise((resolve: (value: ITyntecMoMessage) => void, reject: (reason?: any) => void) => {
if (req.body !== undefined) {
return resolve(req.body);
}
let requestJson = '';
req.on!('data', (chunk: string) => {
if (requestJson.length + chunk.length > this.maxBodySize) {
reject(new Error(`Request body too large: > ${this.maxBodySize}`));
}
requestJson += chunk;
});
req.on!('end', (): void => {
try {
resolve(JSON.parse(requestJson));
} catch (e) {
reject(e);
}
});
});
const activity = await this.parseTyntecWhatsAppMessageEvent({body: requestBody, headers: req.headers, params: req.params, query: req.query});
const context = new TurnContext(this as any, activity);
await this.runMiddleware(context, logic);
res.status(200);
res.end();
} catch (e) {
res.status(500);
res.send(`Failed to process request: ${e}`);
res.end();
}
}
async sendActivities(context: TurnContext, activities: Partial<Activity>[]): Promise<ResourceResponse[]> {
const responses: ResourceResponse[] = [];
for (const activity of activities) {
const tyntecRequest = this.composeTyntecWhatsAppMessageRequest(activity);
const axiosRequest = composeTyntecSendWhatsAppMessageRequestConfig(this.tyntecApikey, tyntecRequest);
axiosRequest.validateStatus = () => true;
const axiosResponse = await this.axiosInstance.request(axiosRequest);
const messageId = parseTyntecSendWhatsAppMessageResponse(axiosResponse);
responses.push({id: messageId});
}
return responses;
}
async updateActivity(context: TurnContext, activity: Partial<Activity>): Promise<ResourceResponse | void> {
throw Error("Operation updateActivity not supported.");
}
protected composeTyntecWhatsAppMessageRequest(activity: Partial<Activity>): ITyntecWhatsAppMessageRequest {
if (activity.type !== ActivityTypes.Message) {
throw Error(`TyntecWhatsAppAdapter: Activity.type other than ${ActivityTypes.Message} not supported: ${activity.type}`);
}
if (activity.attachmentLayout !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.attachmentLayout not supported: ${activity.attachmentLayout}`);
}
if (activity.channelId !== "whatsapp") {
throw Error(`TyntecWhatsAppAdapter: Activity.channelId other than whatsapp not supported: ${activity.channelId}`);
}
if (activity.conversation === undefined) {
throw Error(`TyntecWhatsAppAdapter: Activity.conversation is required: ${activity.conversation}`);
}
if (activity.deliveryMode !== undefined) {
throw Error(`TyntecWhatsAppAdapter: Activity.deliveryMode not supported: ${activity.deliveryMode}`);
}
if (activity.entities !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.entities not supported: ${activity.entities}`);
}
if (activity.expiration !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.expiration not supported: ${activity.expiration}`);
}
if (activity.from === undefined) {
throw Error(`TyntecWhatsAppAdapter: Activity.from is required: ${activity.from}`);
}
if (activity.id !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.id not supported: ${activity.id}`);
}
if (activity.importance !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.importance not supported: ${activity.importance}`);
}
if (activity.inputHint !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.inputHint not supported: ${activity.inputHint}`);
}
if (activity.listenFor !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.listenFor not supported: ${activity.listenFor}`);
}
if (activity.locale !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.locale not supported: ${activity.locale}`);
}
if (activity.replyToId !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.replyToId not supported: ${activity.replyToId}`);
}
if (activity.semanticAction !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.semanticAction not supported: ${activity.semanticAction}`);
}
if (activity.speak !== undefined) {
throw Error(`TyntecWhatsAppAdapter: Activity.speak not supported: ${activity.speak}`);
}
if (activity.suggestedActions !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.suggestedActions not supported: ${activity.suggestedActions}`);
}
if (activity.textFormat !== undefined) {
throw Error(`TyntecWhatsAppAdapter: Activity.textFormat not supported: ${activity.textFormat}`);
}
if (activity.channelData?.contentType === undefined || activity.channelData?.contentType === "text") {
if (activity.attachments !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both text Activity.channelData.contentType and Activity.attachments not supported: ${activity.channelData?.contentType} and ${JSON.stringify(activity.attachments)}`);
}
if (activity.channelData?.contacts !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both text Activity.channelData.contentType and Activity.channelData.contacts not supported: ${activity.channelData?.contentType} and ${JSON.stringify(activity.channelData?.contacts)}`);
}
if (activity.channelData?.interactive !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both text Activity.channelData.contentType and Activity.channelData.interactive not supported: ${activity.channelData?.contentType} and ${JSON.stringify(activity.channelData?.interactive)}`);
}
if (activity.channelData?.location !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both text Activity.channelData.contentType and Activity.channelData.location not supported: ${activity.channelData?.contentType} and ${JSON.stringify(activity.channelData?.location)}`);
}
if (activity.channelData?.template !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both text Activity.channelData.contentType and Activity.channelData.template not supported: ${activity.channelData?.contentType} and ${JSON.stringify(activity.channelData?.template)}`);
}
if (activity.text === undefined) {
throw Error(`TyntecWhatsAppAdapter: text Activity.channelData.contentType requires Activity.text: ${activity.text}`);
}
return {
from: activity.from.id,
to: activity.conversation.id,
channel: "whatsapp",
content: {
contentType: "text",
text: activity.text
}
};
}
if (activity.channelData!.contentType === "audio" || activity.channelData!.contentType === "document" || activity.channelData!.contentType === "image" || activity.channelData!.contentType === "sticker" || activity.channelData!.contentType === "video") {
if (activity.attachments === undefined || activity.attachments.length !== 1) {
throw Error(`TyntecWhatsAppAdapter: other than exactly one Activity.attachments not supported: ${activity.attachments?.length}`);
}
if (activity.attachments[0].content !== undefined) {
throw Error(`TyntecWhatsAppAdapter: Activity.attachments.content not supported: ${activity.attachments[0].content}`);
}
if (activity.attachments[0].contentUrl === undefined) {
throw Error(`TyntecWhatsAppAdapter: Activity.attachments.contentUrl is required: ${activity.attachments[0].contentUrl}`);
}
if (activity.attachments[0].thumbnailUrl !== undefined) {
console.warn(`TyntecWhatsAppAdapter: Activity.attachments.thumbnailUrl not supported: ${activity.attachments[0].thumbnailUrl}`);
}
if (activity.channelData!.contacts !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both media Activity.channelData.contentType and Activity.channelData.contacts not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.contacts)}`);
}
if (activity.channelData!.interactive !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both media Activity.channelData.contentType and Activity.channelData.interactive not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.interactive)}`);
}
if (activity.channelData!.location !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both media Activity.channelData.contentType and Activity.channelData.location not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.location)}`);
}
if (activity.channelData!.template !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both media Activity.channelData.contentType and Activity.channelData.template not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.template)}`);
}
if (activity.channelData!.contentType === "audio") {
if (activity.text !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both audio Activity.channelData.contentType and Activity.text not supported: ${activity.channelData.contentType} and ${activity.text}`);
}
return {
from: activity.from.id,
to: activity.conversation.id,
channel: "whatsapp",
content: {
audio: {
url: activity.attachments[0].contentUrl
},
contentType: "audio"
}
};
}
if (activity.channelData!.contentType === "document") {
return {
from: activity.from.id,
to: activity.conversation.id,
channel: "whatsapp",
content: {
contentType: "document",
document: {
caption: activity.text,
filename: activity.attachments[0].name,
url: activity.attachments[0].contentUrl
}
}
};
}
if (activity.channelData!.contentType === "image") {
return {
from: activity.from.id,
to: activity.conversation.id,
channel: "whatsapp",
content: {
contentType: "image",
image: {
caption: activity.text,
url: activity.attachments[0].contentUrl
}
}
};
}
if (activity.channelData!.contentType === "sticker") {
if (activity.text !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both sticker Activity.channelData.contentType and Activity.text not supported: ${activity.channelData.contentType} and ${activity.text}`);
}
return {
from: activity.from.id,
to: activity.conversation.id,
channel: "whatsapp",
content: {
contentType: "sticker",
sticker: {
url: activity.attachments[0].contentUrl
}
}
};
}
if (activity.channelData!.contentType === "video") {
return {
from: activity.from.id,
to: activity.conversation.id,
channel: "whatsapp",
content: {
contentType: "video",
video: {
caption: activity.text,
url: activity.attachments[0].contentUrl
}
}
};
}
}
if (activity.channelData!.contentType === "contacts") {
if (activity.attachments !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both contacts Activity.channelData.contentType and Activity.attachments not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.attachments)}`);
}
if (activity.channelData!.contacts === undefined) {
throw Error(`TyntecWhatsAppAdapter: contacts Activity.channelData.contentType requires Activity.channelData.contacts: ${activity.channelData.contacts}`);
}
if (activity.channelData!.interactive !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both contacts Activity.channelData.contentType and Activity.channelData.interactive not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.interactive)}`);
}
if (activity.channelData!.location !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both contacts Activity.channelData.contentType and Activity.channelData.location not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.location)}`);
}
if (activity.channelData!.template !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both contacts Activity.channelData.contentType and Activity.channelData.template not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.template)}`);
}
if (activity.text !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both contacts Activity.channelData.contentType and Activity.text not supported: ${activity.channelData.contentType} and ${activity.text}`);
}
return {
from: activity.from.id,
to: activity.conversation.id,
channel: "whatsapp",
content: {
contentType: "contacts",
contacts: activity.channelData!.contacts
}
};
}
if (activity.channelData!.contentType === "interactive") {
if (activity.attachments !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both interactive Activity.channelData.contentType and Activity.attachments not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.attachments)}`);
}
if (activity.channelData!.contacts !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both interactive Activity.channelData.contentType and Activity.channelData.contacts not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.contacts)}`);
}
if (activity.channelData!.interactive === undefined) {
throw Error(`TyntecWhatsAppAdapter: interactive Activity.channelData.contentType requires Activity.channelData.interactive: ${activity.channelData.interactive}`);
}
if (activity.channelData!.location !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both interactive Activity.channelData.contentType and Activity.channelData.location not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.location)}`);
}
if (activity.channelData!.template !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both interactive Activity.channelData.contentType and Activity.channelData.template not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.template)}`);
}
if (activity.text !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both interactive Activity.channelData.contentType and Activity.text not supported: ${activity.channelData.contentType} and ${activity.text}`);
}
return {
from: activity.from.id,
to: activity.conversation.id,
channel: "whatsapp",
content: {
contentType: "interactive",
interactive: activity.channelData!.interactive
}
};
}
if (activity.channelData!.contentType === "location") {
if (activity.attachments !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both location Activity.channelData.contentType and Activity.attachments not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.attachments)}`);
}
if (activity.channelData!.contacts !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both location Activity.channelData.contentType and Activity.channelData.contacts not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.contacts)}`);
}
if (activity.channelData!.interactive !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both location Activity.channelData.contentType and Activity.channelData.interactive not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.interactive)}`);
}
if (activity.channelData!.location === undefined) {
throw Error(`TyntecWhatsAppAdapter: location Activity.channelData.contentType requires Activity.channelData.location: ${activity.channelData.location}`);
}
if (activity.channelData!.template !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both location Activity.channelData.contentType and Activity.channelData.template not supported: ${activity.channelData.contentType} and ${JSON.stringify(activity.channelData.template)}`);
}
if (activity.text !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both location Activity.channelData.contentType and Activity.text not supported: ${activity.channelData.contentType} and ${activity.text}`);
}
return {
from: activity.from.id,
to: activity.conversation.id,
channel: "whatsapp",
content: {
contentType: "location",
location: activity.channelData!.location
}
};
}
if (activity.channelData!.contentType === "template") {
if (activity.attachments !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both Activity.attachments and template Activity.channelData.contentType not supported: ${JSON.stringify(activity.attachments)} and ${activity.channelData.contentType}`);
}
if (activity.channelData!.contacts !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both Activity.channelData.contacts and template Activity.channelData.contentType not supported: ${JSON.stringify(activity.channelData.contacts)} and ${activity.channelData.contentType}`);
}
if (activity.channelData!.interactive !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both Activity.channelData.interactive and template Activity.channelData.contentType not supported: ${JSON.stringify(activity.channelData.interactive)} and ${activity.channelData.contentType}`);
}
if (activity.channelData!.location !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both Activity.channelData.location and template Activity.channelData.contentType not supported: ${JSON.stringify(activity.channelData.location)} and ${activity.channelData.contentType}`);
}
if (activity.channelData!.template === undefined) {
throw Error(`TyntecWhatsAppAdapter: template Activity.channelData.contentType requires Activity.channelData.template: ${activity.channelData.template}`);
}
if (activity.text !== undefined) {
throw Error(`TyntecWhatsAppAdapter: both Activity.text and template Activity.channelData.contentType not supported: ${activity.text} and ${activity.channelData.contentType}`);
}
return {
from: activity.from.id,
to: activity.conversation.id,
channel: "whatsapp",
content: {
contentType: "template",
template: activity.channelData!.template
}
};
}
throw Error(`TyntecWhatsAppAdapter: invalid input: ${activity}`);
}
// Deprecated since version 1.3.0. Use parseTyntecWebhookRequest instead.
protected async parseTyntecWhatsAppMessageEvent(req: {body: ITyntecMoMessage, headers: any, params: any, query: any}): Promise<Partial<Activity>> {
return this.parseTyntecWebhookRequest(req);
}
protected async parseTyntecWebhookRequest(req: {body: ITyntecAPIEvent, headers: any, params: any, query: any}): Promise<Partial<Activity>> {
if (req.body.event === "MoMessage") {
return this.parseTyntecWebhookWhatsAppMoMessage(req.body as ITyntecMoMessage);
}
if (req.body.event === "MoMessage::Postback") {
return this.parseTyntecWebhookMoMessagePostback(req.body as ITyntecMoMessagePostback);
}
throw Error(`TyntecWhatsAppAdapter: ITyntecMoMessage.event other than MoMessage or MoMessage::Postback not supported: ${req.body.event}`)
}
protected async parseTyntecWebhookWhatsAppMoMessage(message: ITyntecMoMessage): Promise<Partial<Activity>> {
if (message.content.contentType === "media" && (message.content.media.type !== "audio" && message.content.media.type !== "document" && message.content.media.type !== "image" && message.content.media.type !== "sticker" && message.content.media.type !== "video" && message.content.media.type !== "voice")) {
throw Error(`TyntecWhatsAppAdapter: ITyntecMoMessage.content.media.type other than audio, document, image, sticker and video not supported: ${message.content.media.type}`);
}
if (message.groupId !== undefined) {
throw Error(`TyntecWhatsAppAdapter: ITyntecMoMessage.groupId not supported: ${message.groupId}`)
}
if (message.to === undefined) {
throw Error(`TyntecWhatsAppAdapter: ITyntecMoMessage.to is required: ${message.to}`)
}
const recipient: Partial<ChannelAccount> = {
id: message.to
};
const activity: Partial<Activity> = {
...this.parseTyntecWebhookAPIEvent(message),
channelData: {},
id: message.messageId,
recipient: recipient as ChannelAccount,
replyToId: message.context?.messageId,
type: ActivityTypes.Message
};
if (message.whatsapp?.senderName) {
const conversation = activity.conversation as Partial<ConversationAccount>;
conversation.name = message.whatsapp?.senderName;
const from = activity.from as Partial<ChannelAccount>;
from.name = message.whatsapp?.senderName;
}
if (message.content.contentType === "text") {
activity.channelData.contentType = "text";
activity.text = message.content.text;
return activity;
}
if (message.content.contentType === "contacts") {
activity.channelData.contentType = "contacts";
activity.channelData.contacts = message.content.contacts;
return activity;
}
if (message.content.contentType === "location") {
activity.channelData.contentType = "location";
activity.channelData.location = message.content.location;
return activity;
}
if (message.content.contentType === "media") {
const mediaRequest = composeTyntecRequestConfig("get", message.content.media.url, this.tyntecApikey, "*/*");
mediaRequest.validateStatus = () => true;
let mediaResponse;
try{
mediaResponse = await this.axiosInstance.request(mediaRequest);
} catch (e: any) {
throw new Error(`Failed to download media: ${e.response.status}: ${JSON.stringify(e.response.data)}`);
}
activity.attachments = [
{
contentType: mediaResponse.headers["content-type"],
contentUrl: message.content.media.url
}
];
activity.channelData.contentType = message.content.media.type;
activity.text = message.content.media.caption;
return activity;
}
throw Error(`TyntecWhatsAppAdapter: invalid input: ${JSON.stringify(message)}`);
}
protected async parseTyntecWebhookMoMessagePostback(message: ITyntecMoMessagePostback): Promise<Partial<Activity>> {
if (message.groupId !== undefined) {
throw Error(`TyntecWhatsAppAdapter: ITyntecMoMessage.groupId not supported: ${message.groupId}`)
}
if (message.to === undefined) {
throw Error(`TyntecWhatsAppAdapter: ITyntecMoMessage.to is required: ${message.to}`)
}
const recipient: Partial<ChannelAccount> = {
id: message.to
};
const activity: Partial<Activity> = {
...this.parseTyntecWebhookAPIEvent(message),
channelData: {
contentType: "postback",
postback: {
data: message.postback.data
}
},
id: message.messageId,
recipient: recipient as ChannelAccount,
replyToId: message.context?.messageId,
type: ActivityTypes.Message
};
if (message.whatsapp) {
activity.channelData.postback.whatsapp = {
description: message.whatsapp.description,
text: message.whatsapp.text,
title: message.whatsapp.title
}
}
return activity;
}
protected parseTyntecWebhookAPIEvent(event: ITyntecAPIEvent): Partial<Activity> {
const tyntecSendWhatsAppMessageRequestConfig = composeTyntecSendWhatsAppMessageRequestConfig(this.tyntecApikey, {from: "example", to: "example", channel: "whatsapp", content: {contentType: "text", text: "example"}});
const conversation: Partial<ConversationAccount> = {
id: event.from,
isGroup: false
};
const from: Partial<ChannelAccount> = {
id: event.from
};
return {
channelId: event.channel,
conversation: conversation as ConversationAccount,
from: from as ChannelAccount,
serviceUrl: tyntecSendWhatsAppMessageRequestConfig.url,
timestamp: event.timestamp !== undefined ? new Date(event.timestamp) : undefined
};
}
}
|
Clechay/Ram-Maszyna-2
|
src/components/Control.tsx
|
import * as React from 'react';
import { Action } from 'utils/Action';
export interface Props {
handler: (e: Action) => void;
}
export class Control extends React.Component<Props, object> {
render() {
const {handler} = this.props;
return (
<div className="control">
<button onClick={() => handler(new Action('build'))}>build</button>
<button onClick={() => handler(new Action('play'))}>play</button>
<button onClick={() => handler(new Action('step'))}>step</button>
<button onClick={() => handler(new Action('debug'))}>debug</button>
</div>
);
}
}
|
Clechay/Ram-Maszyna-2
|
src/rm/ribbon.test.ts
|
import { InputRibbon, OutputRibbon } from './ribbon';
it('InputRibbon is supposed to be empty by default', () => {
const empty = new InputRibbon([]);
expect(empty.getPrevious()).toEqual([]);
expect(empty.getCurrent()).toEqual(undefined);
expect(empty.getFollowing()).toEqual([]);
});
it('OutputRibbon is supposed to be empty by default', () => {
const empty = new OutputRibbon();
expect(empty.getPrevious()).toEqual([]);
expect(empty.getCurrent()).toEqual(undefined);
expect(empty.getFollowing()).toEqual([]);
});
let arrs = [
[12, 31, 2412, 412, 13, 123],
[12, 31, 2412, 412, 13, 123],
[12, 31, 2412, 412, 13, 123],
[12, 31, 2412, 412, 13, 123],
[12, 31, 2412, 412, 13, 123]
];
it('InputRibbon is supposed to return elements in order [using readAndMove]', () => {
arrs.forEach((val, index, tab) => {
let rb = new InputRibbon(val);
val.forEach((sv, si, st) => {
expect(sv).toBe(rb.readAndMove());
});
});
});
it('InputRibbon is supposed to return elements in order [using read followed with move]', () => {
arrs.forEach((val, index, tab) => {
let rb = new InputRibbon(val);
val.forEach((sv, si, st) => {
expect(sv).toBe(rb.read());
rb.move();
});
});
});
it('read is not supposed to change index', () => {
arrs.forEach((val, index, tab) => {
let rb = new InputRibbon(val);
val.forEach((sv, si, st) => {
expect(st[0]).toBe(rb.read());
});
});
});
it('OutputRibbon is supposed to store elements in order [writeAndMove]', () => {
arrs.forEach((val, index, tab) => {
let or = new OutputRibbon();
val.forEach((sv, si, st) => {
or.writeAndMove(sv);
});
expect(val).toEqual(or.getEntire());
});
});
it('OutputRibbon is supposed to store elements in order [write followed with move]', () => {
arrs.forEach((val, index, tab) => {
let or = new OutputRibbon();
val.forEach((sv, si, st) => {
or.write(sv);
or.move();
});
expect(val).toEqual(or.getEntire());
});
});
it('write is not supposed to change index', () => {
arrs.forEach((val, index, tab) => {
let or = new OutputRibbon();
val.forEach((sv, si, st) => {
or.write(sv);
});
expect([val[val.length - 1]]).toEqual(or.getEntire());
});
});
|
Clechay/Ram-Maszyna-2
|
src/rm/state.test.ts
|
import { State } from './state';
it('State is not supposed to have any undefined elements', () => {
const empty = new State([1, 3, 3, 7]);
expect(empty.in).toBeDefined();
expect(empty.out).toBeDefined();
expect(empty.mem).toBeDefined();
expect(empty.commandCounter).toBeDefined();
});
it('States counter is supposed to start with 0', () => {
const empty = new State([1, 3, 3, 7]);
expect(empty.commandCounter).toEqual(0);
});
it('States constructor is supposed to pass argument to InputRibbon', () => {
const empty = new State([1, 3, 3, 7]);
expect(empty.in.getEntire()).toEqual([1, 3, 3, 7]);
});
|
Clechay/Ram-Maszyna-2
|
src/rm/engine.ts
|
import { Command, DataToken, DataTokenType, Firmware } from './firmware';
import { State } from './state';
import { Terminator } from './termination';
export class Executor {
name: string;
handlers: Map<DataTokenType, (prev: State, arg: DataToken, firm: Firmware) => State>;
static getAddr(label: string, firm: Firmware) {
let id = firm.map.get(label);
if (typeof id === typeof undefined) throw 'unable to find label "' + label + '" in map ' + firm.map;
return id;
}
doable(argT: DataTokenType): boolean {
return this.handlers.has(argT);
}
exec(prev: State, arg: DataToken, firm: Firmware): State {
if (!this.doable(arg.type)) {
throw 'illegal argument type';
}
return this.handlers.get(arg.type)(prev, arg, firm);
}
constructor(name: string) {
this.name = name;
this.handlers = new Map<DataTokenType, (prev: State, arg: DataToken) => State>();
}
}
let executors: Executor[] = [];
let ex;
// TEST
ex = new Executor('TEST');
ex.handlers.set(DataTokenType.NULL, (prev, arg, firm) => {
prev.mem.set(42, 1337);
return prev;
});
executors.push(ex);
// NOP
ex = new Executor('NOP');
ex.handlers.set(DataTokenType.NULL, (prev, arg, firm) => {
return prev;
});
executors.push(ex);
// ADD
ex = new Executor('ADD');
ex.handlers.set(DataTokenType.NUMBER, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) + arg.value);
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_NUMBER, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) + prev.mem.get(arg.value));
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_ADDRESS, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) + prev.mem.get(prev.mem.get(arg.value)));
return prev;
});
executors.push(ex);
// SUB
ex = new Executor('SUB');
ex.handlers.set(DataTokenType.NUMBER, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) - arg.value);
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_NUMBER, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) - prev.mem.get(arg.value));
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_ADDRESS, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) - prev.mem.get(prev.mem.get(arg.value)));
return prev;
});
executors.push(ex);
// MULT
ex = new Executor('MULT');
ex.handlers.set(DataTokenType.NUMBER, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) * arg.value);
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_NUMBER, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) * prev.mem.get(arg.value));
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_ADDRESS, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) * prev.mem.get(prev.mem.get(arg.value)));
return prev;
});
executors.push(ex);
// DIV
ex = new Executor('DIV');
ex.handlers.set(DataTokenType.NUMBER, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) / arg.value);
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_NUMBER, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) / prev.mem.get(arg.value));
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_ADDRESS, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) / prev.mem.get(prev.mem.get(arg.value)));
return prev;
});
executors.push(ex);
// MOD
ex = new Executor('MOD');
ex.handlers.set(DataTokenType.NUMBER, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) % arg.value);
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_NUMBER, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) % prev.mem.get(arg.value));
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_ADDRESS, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(0) % prev.mem.get(prev.mem.get(arg.value)));
return prev;
});
executors.push(ex);
// LOAD
ex = new Executor('LOAD');
ex.handlers.set(DataTokenType.NUMBER, (prev, arg, firm) => {
prev.mem.set(0, arg.value);
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_NUMBER, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(arg.value));
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_ADDRESS, (prev, arg, firm) => {
prev.mem.set(0, prev.mem.get(prev.mem.get(arg.value)));
return prev;
});
executors.push(ex);
// STORE
ex = new Executor('STORE');
ex.handlers.set(DataTokenType.ADDRESS_TO_NUMBER, (prev, arg, firm) => {
prev.mem.set(arg.value, prev.mem.get(0));
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_ADDRESS, (prev, arg, firm) => {
prev.mem.set(prev.mem.get(arg.value), prev.mem.get(0));
return prev;
});
executors.push(ex);
// JUMP
ex = new Executor('JUMP');
ex.handlers.set(DataTokenType.LABEL, (prev, arg, firm) => {
prev.commandCounter = Executor.getAddr(arg.value, firm) - 1;
return prev;
});
executors.push(ex);
// JZERO
ex = new Executor('JZERO');
ex.handlers.set(DataTokenType.LABEL, (prev, arg, firm) => {
if (prev.mem.get(0) === 0)
prev.commandCounter = Executor.getAddr(arg.value, firm) - 1;
return prev;
});
executors.push(ex);
// JGTZ
ex = new Executor('JGTZ');
ex.handlers.set(DataTokenType.LABEL, (prev, arg, firm) => {
if (prev.mem.get(0) >= 0)
prev.commandCounter = Executor.getAddr(arg.value, firm) - 1;
return prev;
});
executors.push(ex);
// JLTZ
ex = new Executor('JLTZ');
ex.handlers.set(DataTokenType.LABEL, (prev, arg, firm) => {
if (prev.mem.get(0) <= 0)
prev.commandCounter = Executor.getAddr(arg.value, firm) - 1;
return prev;
});
executors.push(ex);
// WRITE
ex = new Executor('WRITE');
ex.handlers.set(DataTokenType.NUMBER, (prev, arg, firm) => {
prev.out.writeAndMove(arg.value);
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_NUMBER, (prev, arg, firm) => {
prev.out.writeAndMove(prev.mem.get(arg.value));
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_ADDRESS, (prev, arg, firm) => {
prev.out.writeAndMove(prev.mem.get(prev.mem.get(arg.value)));
return prev;
});
executors.push(ex);
// READ
ex = new Executor('READ');
ex.handlers.set(DataTokenType.ADDRESS_TO_NUMBER, (prev, arg, firm) => {
prev.mem.set(arg.value, prev.in.readAndMove());
return prev;
});
ex.handlers.set(DataTokenType.ADDRESS_TO_ADDRESS, (prev, arg, firm) => {
prev.mem.set(prev.mem.get(arg.value), prev.in.readAndMove());
return prev;
});
executors.push(ex);
// HALT
ex = new Executor('HALT');
ex.handlers.set(DataTokenType.NULL, (prev, arg, firm) => {
prev.halted = true;
return prev;
});
executors.push(ex);
export class Engine {
executors: Map<string, Executor>;
static nextCmd(s: State, f: Firmware): Command {
return f.commands[s.commandCounter];
}
static halt(s: State, f: Firmware): boolean {
return s.halted;
}
constructor() {
this.executors = new Map<string, Executor>();
executors.forEach((value, index, array) => {
this.executors.set(value.name, value);
});
}
step(prev: State, firmware: Firmware): State {
let cmd = Engine.nextCmd(prev, firmware);
let exe = this.executors.get(cmd.id);
if (typeof exe !== 'undefined') {
if (exe.doable(cmd.arg.type)) {
exe.exec(prev, cmd.arg, firmware);
if (!Engine.halt(prev, firmware)) prev.commandCounter++;
}
else throw 'unsupported command arg type ' + cmd.arg;
}
else {
throw 'unsupported command id ' + cmd.id;
}
return prev;
}
execute(prev: State, firmware: Firmware): State {
let c = 0;
while (!Engine.halt(prev, firmware)) {
c++;
prev = this.step(prev, firmware);
}
return prev;
}
debug(prev: State, firmware: Firmware, term: Terminator): State {
while (!term.check(Object.assign(Object, prev), firmware) && !Engine.halt(prev, firmware)) {
this.step(prev, firmware);
}
return prev;
}
}
|
Clechay/Ram-Maszyna-2
|
src/rm/firmware.test.ts
|
import { Firmware, Command, DataTokenType, DataToken } from './firmware';
let validCmds = [
'asa: AS 1333',
'asa: AS ^1424',
'asa: AS =1343',
'asa: AS .ser',
'asa: AS',
'AS 1333',
'AS ^1424',
'AS =1343',
'AS .ser',
'AS'
];
let validCmdsInfo = [
{arg: ['1333'], id: ['AS'], label: ['asa'], raw: 'asa: AS 1333'},
{arg: ['^1424'], id: ['AS'], label: ['asa'], raw: 'asa: AS ^1424'},
{arg: ['=1343'], id: ['AS'], label: ['asa'], raw: 'asa: AS =1343'},
{arg: ['.ser'], id: ['AS'], label: ['asa'], raw: 'asa: AS .ser'},
{arg: null, id: ['AS'], label: ['asa'], raw: 'asa: AS'},
{arg: ['1333'], id: ['AS'], label: null, raw: 'AS 1333'},
{arg: ['^1424'], id: ['AS'], label: null, raw: 'AS ^1424'},
{arg: ['=1343'], id: ['AS'], label: null, raw: 'AS =1343'},
{arg: ['.ser'], id: ['AS'], label: null, raw: 'AS .ser'},
{arg: null, id: ['AS'], label: null, raw: 'AS'},
];
it('regex cmd validity', () => {
validCmds.forEach((e) => {
expect(Command.checks.valid.test(e)).toBe(true);
});
});
it('regex extraction', () => {
validCmdsInfo.forEach((e) => {
expect(e.raw.match(Command.checks.label)).toEqual(e.label);
expect(e.raw.match(Command.checks.argument)).toEqual(e.arg);
expect(e.raw.match(Command.checks.id)).toEqual(e.id);
});
});
it('regex arg type', () => {
expect(DataToken.checks.ADDRESS_TO_NUMBER.test('1333')).toBe(true);
expect(DataToken.checks.ADDRESS_TO_NUMBER.test('=1333')).toBe(false);
expect(DataToken.checks.ADDRESS_TO_NUMBER.test('^1333')).toBe(false);
expect(DataToken.checks.ADDRESS_TO_NUMBER.test('.ser')).toBe(false);
expect(DataToken.checks.ADDRESS_TO_ADDRESS.test('1333')).toBe(false);
expect(DataToken.checks.ADDRESS_TO_ADDRESS.test('=1333')).toBe(false);
expect(DataToken.checks.ADDRESS_TO_ADDRESS.test('^1333')).toBe(true);
expect(DataToken.checks.ADDRESS_TO_ADDRESS.test('.ser')).toBe(false);
expect(DataToken.checks.NUMBER.test('1333')).toBe(false);
expect(DataToken.checks.NUMBER.test('=1333')).toBe(true);
expect(DataToken.checks.NUMBER.test('^1333')).toBe(false);
expect(DataToken.checks.NUMBER.test('.ser')).toBe(false);
expect(DataToken.checks.LABEL.test('1333')).toBe(false);
expect(DataToken.checks.LABEL.test('=1333')).toBe(false);
expect(DataToken.checks.LABEL.test('^1333')).toBe(false);
expect(DataToken.checks.LABEL.test('.ser')).toBe(true);
});
let someCode = 'TEST\n// some happy comment\nHALT';
let someCodeNoHalt = 'TEST\n// some happy comment';
it('text from firmware', () => {
let fw = new Firmware(someCode);
expect(someCode).toEqual(fw.text());
});
it('auto HALT addition', () => {
let fw = new Firmware(someCodeNoHalt);
expect(someCodeNoHalt + '\nHALT').toEqual(fw.text());
});
|
Clechay/Ram-Maszyna-2
|
src/utils/Action.ts
|
export class Action {
id: string;
payload: object;
constructor(id: string, payload?: object) {
this.id = id;
this.payload = payload;
}
}
|
Clechay/Ram-Maszyna-2
|
src/rm/termination.ts
|
<reponame>Clechay/Ram-Maszyna-2
import { Firmware } from './firmware';
import { State } from './state';
export class TerminationRule {
check(state: State, firmware: Firmware): boolean {
return false;
}
}
export class TerminateAtLine extends TerminationRule {
nr: number;
constructor(lineNumber: number) {
super();
this.nr = lineNumber;
}
check(state: State, firmware: Firmware): boolean {
return state.commandCounter === this.nr;
}
}
export class Terminator {
rules: TerminationRule[];
addRule(r: TerminationRule): void {
this.rules.push(r);
}
check(state: State, firmware: Firmware): boolean {
for (let r of this.rules) {
if (r.check(state, firmware)) return true;
}
return false;
}
}
|
Clechay/Ram-Maszyna-2
|
src/components/Editor.tsx
|
import * as React from 'react';
import './App.css';
import { Code } from 'components/Code';
import { Control } from 'components/Control';
import { Engine } from 'root/rm/engine';
import { RM } from 'root/rm/rm';
import { State } from 'root/rm/state';
import { Firmware } from 'root/rm/firmware';
import { clone } from 'clone';
import { Terminator } from 'root/rm/termination';
import { Action } from 'utils/Action';
const logo = require('assets/logo.svg');
export class Editor extends React.Component<object, object> {
rm: RM;
update_state(): void {
this.setState({rmDisplayedState: clone(this.rm.state)});
}
update_code(nc: string): void {
this.setState({rmDisplayedState: clone(this.rm.state)});
}
get_code(): string {
return this.rm.firmware.text();
}
ctrl_handler(e: Action): void {
console.log(this);
switch (e.id) {
case 'play':
this.rm.execute();
break;
case 'debug':
console.error('not ready');
break;
case 'step':
this.rm.step();
break;
default:
console.error('sth went wrong, unknown event name at ctrl_handler');
break;
}
}
constructor(props) {
super(props);
this.rm = new RM(undefined, undefined, undefined);
this.state = {
code: 'HALT',
input: [],
output: [],
rmDisplayedState: State
};
this.update_state.bind(this);
this.update_code.bind(this);
this.get_code.bind(this);
this.ctrl_handler.bind(this);
}
render() {
this.ctrl_handler(new Action('ojej'));
return (
<div className="App">
<Control handler={(e: Action) => this.ctrl_handler(e)}/>
<Code handler={(e) => undefined} text={this.get_code()}/>
</div>
);
}
}
|
Clechay/Ram-Maszyna-2
|
src/components/App.tsx
|
import * as React from 'react';
import './App.css';
import { Editor } from './Editor';
const logo = require('assets/logo.svg');
class App extends React.Component<object, object> {
constructor(props) {
super(props);
}
render() {
return (
<Editor/>
);
}
}
export default App;
|
Clechay/Ram-Maszyna-2
|
src/rm/memmory.test.ts
|
import { Memmory } from './memmory';
let arrs = [
[0, 11],
[1, 2312],
[2, 5346],
[4, 575],
[100, 0],
[1000, -11],
[10000, 7],
[9001, 0]
];
it('Memmory should store set values', () => {
let m = new Memmory();
arrs.forEach((v, i, t) => {
m.set(v[0], v[1]);
});
arrs.forEach((v, i, t) => {
expect(m.get(v[0])).toBe(v[1]);
});
});
it('Memmory should not add own values', () => {
// TEST TO EXPENSIVE
// let m = new Memmory();
// arrs.forEach((v,i,t)=>{expect(m.get(v[0])).toBe(v[1]);
// m.set(v[0],v[1]);
// });
// let er = [];
// arrs.forEach((v,i,t)=>{
// er[v[0]]=v[1];
// });
// er = er.filter((e)=>{return typeof e !== typeof undefined})
// er.forEach( (v,i,t) => expect(v).toBe(m.getAll[i]) );
});
|
Clechay/Ram-Maszyna-2
|
src/rm/engine.test.ts
|
import { Engine } from './engine';
import { State } from './state';
import { Firmware } from './firmware';
let e = new Engine();
it('step', () => {
let s = new State([0, 1, 2, 3, 4]);
let f = new Firmware('TEST\nHALT');
e.step(s, f);
expect(1337).toBe(s.mem.get(42));
});
it('step', () => {
let s = new State([0, 1, 2, 3, 4]);
let f = new Firmware('TEST\nHALT');
e.execute(s, f);
expect(1337).toBe(s.mem.get(42));
});
it('integration', () => {
let srcCode = [
'LOAD =0',
'STORE 1',
'czytaj: READ 0',
'JZERO .koniec',
'ADD 1',
'STORE 1',
'JUMP .czytaj',
'koniec: WRITE 1',
'HALT'
].reduce((a, b) => a + '\n' + b, '').substring(1);
let s = new State([1, 2, 3, 0]);
let f = new Firmware(srcCode);
console.log(f);
e.execute(s, f);
expect(s.out.getEntire()).toEqual([6]);
console.log(s);
});
|
Clechay/Ram-Maszyna-2
|
src/rm/state.ts
|
import { InputRibbon, OutputRibbon } from './ribbon';
import { Memmory } from './memmory';
export class State {
halted: boolean;
in: InputRibbon;
out: OutputRibbon;
mem: Memmory;
commandCounter: number;
constructor(input: number[]) {
this.halted = false;
this.in = new InputRibbon(input);
this.out = new OutputRibbon();
this.mem = new Memmory();
this.commandCounter = 0;
}
}
|
Clechay/Ram-Maszyna-2
|
src/components/Output.tsx
|
<reponame>Clechay/Ram-Maszyna-2
import * as React from 'react';
import { Action } from 'utils/Action';
export interface Props {
elems: number[];
}
export interface PropsElem {
el: number | string;
}
class Elem extends React.Component<PropsElem, object> {
render() {
const {el} = this.props;
return <li>{el}</li>;
}
}
export class Output extends React.Component<Props, object> {
render() {
const {elems} = this.props;
return (
<div className="ribbon ribbonOut">
<ul>
<li className="header">out:</li>
{elems.map((e, index) => <Elem el={e} key={index}/>)}
</ul>
</div>
);
}
}
|
Clechay/Ram-Maszyna-2
|
src/components/Code.tsx
|
import * as React from 'react';
import { Action } from 'utils/Action';
export interface Props {
handler: (e: Action) => void;
text: string;
}
export class Code extends React.Component<Props, object> {
render() {
const {handler, text} = this.props;
return (
<div className="code">
<textarea
className="source_code"
onChange={(e) => {
handler(new Action('code_update', {newCode: e.target.value}));
}}
>
{text}
</textarea>
</div>
);
}
}
|
Clechay/Ram-Maszyna-2
|
src/rm/firmware.ts
|
// types of arguments
export enum DataTokenType {
NUMBER,
ADDRESS_TO_NUMBER,
ADDRESS_TO_ADDRESS,
LABEL,
NULL
}
// argument class
export class DataToken {
static checks = {
NUMBER: /^=\d+$/,
ADDRESS_TO_NUMBER: /^\d+$/,
ADDRESS_TO_ADDRESS: /^\^\d+$/,
LABEL: /^\.([a-z])\w*$/,
};
type: DataTokenType;
value: string | number | null;
constructor(raw: string) {
this.value = raw;
if (raw === '' || raw === null) {
this.type = DataTokenType.NULL;
this.value = null;
}
else if (DataToken.checks.NUMBER.test(raw)) {
this.type = DataTokenType.NUMBER;
this.value = Number(this.value.substring(1));
}
else if (DataToken.checks.ADDRESS_TO_ADDRESS.test(raw)) {
this.type = DataTokenType.ADDRESS_TO_ADDRESS;
this.value = Number(this.value.substring(1));
}
else if (DataToken.checks.ADDRESS_TO_NUMBER.test(raw)) {
this.type = DataTokenType.ADDRESS_TO_NUMBER;
this.value = Number(this.value);
}
else if (DataToken.checks.LABEL.test(raw)) {
this.type = DataTokenType.LABEL;
this.value = this.value.substring(1);
}
else throw 'unknown argument type';
}
}
export class Command {
static checks = {
valid: /(([a-z])+:\s)?([A-Z])+(\s(\.([a-z])+|(([\^=])?\d+)))?/,
label: /^([a-z])+(?=\:)/g,
id: /[A-Z]+/g,
argument: /\.([a-z])+|(([\^=])?\d+)/g,
};
raw: string;
label: string | null;
id: string;
arg: DataToken;
static validate_line(line: string): boolean {
return Command.checks.valid.test(line);
}
constructor(raw: string) {
if (!Command.validate_line(raw)) {
this.raw = raw;
this.label = null;
this.id = 'NOP';
this.arg = new DataToken(null);
return;
}
// raw
this.raw = raw;
// label
let label = raw.match(Command.checks.label);
if (label !== null) this.label = label[0];
else this.label = null;
// id
let id = raw.match(Command.checks.id);
if (id !== null) this.id = id[0];
else this.id = null;
// arg
let arg = raw.match(Command.checks.argument);
if (arg !== null) this.arg = new DataToken(arg[0]);
else this.arg = new DataToken(null);
}
}
export class Firmware {
map: Map<string, number>;
commands: Command[];
constructor(raw?: string) {
// code
if (typeof raw === typeof undefined) raw = 'HALT';
let lines = raw.split('\n');
this.commands = lines.map(value => new Command(value));
if (this.commands[this.commands.length - 1].id !== 'HALT')
this.commands.push(new Command('HALT'));
// labels
this.map = new Map<string, number>();
this.commands.forEach((value, index) => {
if (value.label !== '') this.map.set(value.label, index);
});
}
text(): string {
return this.commands.reduce((acc: string, cur) => acc + '\n' + cur.raw, '').substring(1);
}
}
|
Clechay/Ram-Maszyna-2
|
src/rm/rm.ts
|
<reponame>Clechay/Ram-Maszyna-2
import { Engine } from './engine';
import { Firmware } from './firmware';
import { State } from './state';
import { Terminator } from 'root/rm/termination';
export class RM {
engine: Engine;
firmware: Firmware;
state: State;
constructor(eng: Engine | undefined, fir: Firmware | undefined, sta: State | undefined) {
if (typeof eng === typeof undefined) eng = new Engine();
if (typeof fir === typeof undefined) fir = new Firmware();
if (typeof sta === typeof undefined) sta = new State([]);
this.engine = eng;
this.firmware = fir;
this.state = sta;
}
execute(): State {
this.state = this.engine.execute(this.state, this.firmware);
return this.state;
}
debug(term: Terminator): State {
this.state = this.engine.debug(this.state, this.firmware, term);
return this.state;
}
step(): State {
this.state = this.engine.step(this.state, this.firmware);
return this.state;
}
}
|
Clechay/Ram-Maszyna-2
|
src/rm/memmory.ts
|
export class Memmory {
cells: number[];
constructor() {
this.cells = [];
}
set(id: number, value: number): void {
this.cells[id] = value;
}
get(id: number): number {
if (typeof this.cells[id] === typeof undefined) {
// throw 'getting from unused memmory';
this.cells[id] = 0;
}
return this.cells[id];
}
getAll(): number[] {
return Object.assign([], this.cells).filter((e) => {
return typeof e !== typeof undefined;
});
}
}
|
Clechay/Ram-Maszyna-2
|
src/rm/ribbon.ts
|
export class Ribbon {
protected dataSequence: number[];
protected nextId: number;
protected constructor() {
this.nextId = 0;
this.dataSequence = [];
}
move(): void {
this.nextId++;
}
getPrevious(): number[] {
let result: number[] = [];
for (let i = 0; i < this.nextId; i++) {
result.push(this.dataSequence[i]);
}
return result;
}
getCurrent(): number {
return this.dataSequence[this.nextId];
}
getFollowing(): number[] {
let result: number[] = [];
for (let i = this.nextId + 1; i < this.dataSequence.length; i++) {
result.push(this.dataSequence[i]);
}
return result;
}
getEntire(): number[] {
return Object.assign([], this.dataSequence);
}
}
export class InputRibbon extends Ribbon {
constructor(arr: number[]) {
super();
this.dataSequence = Object.assign([], arr);
}
read(): number {
return this.dataSequence[this.nextId];
}
readAndMove(): number {
this.nextId++;
return this.dataSequence[this.nextId - 1];
}
}
export class OutputRibbon extends Ribbon {
constructor() {
super();
this.dataSequence = [];
}
write(val: number): void {
this.dataSequence[this.nextId] = val;
}
writeAndMove(val: number): void {
this.write(val);
this.move();
}
}
|
josundt/supports-color
|
index.test-d.ts
|
import {stdout, stderr} from 'node:process';
import {expectType} from 'tsd';
import supportsColor, {createSupportsColor, Options, ColorInfo} from './index.js';
const options: Options = {};
expectType<ColorInfo>(supportsColor.stdout);
expectType<ColorInfo>(supportsColor.stderr);
expectType<ColorInfo>(createSupportsColor(stdout));
expectType<ColorInfo>(createSupportsColor(stderr));
expectType<ColorInfo>(createSupportsColor(stdout, options));
|
Krinkle/sauce-connect-action
|
test/wait.test.ts
|
<filename>test/wait.test.ts
import {wait} from '../src/wait'
import {promises} from 'fs'
import {join} from 'path'
import {tmpdir} from 'os'
async function touch(filepath: string) {
const fileHandle = await promises.open(filepath, 'w')
return fileHandle.close()
}
describe('watch()', () => {
it('returns a promise which will be resolved when the target file is touched', async () => {
const tmpDir = await promises.mkdtemp(
join(tmpdir(), 'sauce-connect-action-')
)
const readyFile = join(tmpDir, 'sc.ready')
const watcher = wait(tmpDir)
touch(readyFile)
return watcher
})
})
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.