const { Sequelize, DataTypes } = require('sequelize');
// Подключение к базе данных
const sequelize = new Sequelize('database', 'username', 'password', {
host: 'localhost',
dialect: 'mysql',
});
// Определение модели UsersModel
const UsersModel = sequelize.define('User', {
email: {
type: DataTypes.STRING,
allowNull: false,
unique: true,
},
// Другие поля пользователя
});
// Определение модели RolesModel
const RolesModel = sequelize.define('Role', {
title_role: {
type: DataTypes.STRING,
allowNull: false,
},
// Другие поля роли
});
// Определение отношения "один к одному"
UsersModel.hasOne(RolesModel);
RolesModel.belongsTo(UsersModel);
// Пример создания записи пользователя с ролью
sequelize.sync()
.then(async () => {
const user = await UsersModel.create({
email: 'example@example.com',
// Другие поля пользователя
});
const role = await RolesModel.create({
title_role: 'Admin',
// Другие поля роли
});
// Связываем пользователя с ролью
await user.setRole(role);
// Запрос на получение пользователя с ролью
const foundUser = await UsersModel.findOne({
where: { email: 'example@example.com' },
include: RolesModel, // указываем, что хотим включить связанную модель
});
if (!foundUser) {
console.error('Пользователь не найден');
} else {
console.log(foundUser.email + ' - ' + foundUser.Role.title_role);
}
})
.catch((error) => {
console.error('Ошибка при синхронизации с базой данных:', error);
});
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Scroll Animation</title>
<style>
body {
margin: 0;
padding: 0;
height: 200vh; /* чтобы создать прокрутку */
}
.road {
position: relative;
height: 100vh; /* высота видимой области */
overflow: hidden;
}
.container {
position: absolute;
bottom: 0;
left: 50%;
transform: translateX(-50%);
}
.car {
width: 50px;
height: 30px;
background-color: red;
position: absolute;
bottom: 0;
transition: transform 0.3s ease-in-out; /* плавный переход */
}
</style>
</head>
<body>
<section class="road">
<div class="container">
<div class="car"></div>
</div>
</section>
<script src="https://code.jquery.com/jquery-3.6.4.min.js"></script>
<script>
$(document).ready(function () {
$(window).on('scroll', function () {
var scrollTop = $(this).scrollTop();
var windowHeight = $(this).height();
var car = $('.car');
var roadHeight = $('.road').outerHeight();
// Проверка, виден ли автомобиль в текущей области видимости
if (scrollTop <= roadHeight && (scrollTop + windowHeight) >= roadHeight) {
// Изменение размера и положения автомобиля
var scale = 1 + (scrollTop / roadHeight); // регулируйте это значение по вашему вкусу
var translateX = -scrollTop / 5; // регулируйте это значение по вашему вкусу
car.css({
'transform': 'translateX(' + translateX + 'px) scale(' + scale + ')'
});
}
});
});
</script>
</body>
</html>
import React from 'react';
import { FlatList, View, Text, ScrollView } from 'react-native';
const test = [
{id: 1, name: '1'},
{id: 2, name: '2'},
{id: 3, name: '3'},
{id: 4, name: '4'},
];
const App = () => {
return (
<FlatList
data={test}
horizontal
renderItem={({item}) => (
<View
style={{
height: 'auto',
width: 300,
backgroundColor: 'red',
marginLeft: 10,
}}>
<Text>{item.name}</Text>
<ScrollView horizontal contentContainerStyle={{width: '100%', height: 100}}>
{test.map(data => (
<View
key={'lol' + data.id}
style={{
backgroundColor: 'green',
width: 100,
height: 50,
marginLeft: 10,
}}>
</View>
))}
</ScrollView>
</View>
)}
/>
);
};
export default App;
from pydantic import BaseModel
from typing import List
class Period(BaseModel):
year: str
date_from: str
# Используем эту модель для парсинга каждого отдельного периода
# Используем lxml для парсинга xml
from lxml import etree
root = etree.fromstring(xml_text)
periods = []
for i in range(0, len(root), 2):
year = root[i].text
date_from = root[i + 1].text
periods.append(Period(year=year, date_from=date_from))
pprint.pprint(periods)
<Periods>
<Year>01.01.2023 0:00:00</Year>
<Date_from>18.02.2023 0:00:00</Date_from>
<Year>01.01.2023 0:00:00</Year>
<Date_from>28.02.2023 0:00:00</Date_from>
<Year>01.01.2023 0:00:00</Year>
<Date_from>30.05.2023 0:00:00</Date_from>
<Year>01.01.2023 0:00:00</Year>
<Date_from>06.04.2023 0:00:00</Date_from>
<Year>01.01.2023 0:00:00</Year>
<Date_from>19.06.2023 0:00:00</Date_from>
<Year>01.01.2023 0:00:00</Year>
<Date_from>07.06.2023 0:00:00</Date_from>
</Periods>
GET /rest/1/site/iblock.Element.get?iblockElementId=1&iblockId=1&lang=ru&fields=IBLOCK_ELEMENT_PROPERTIES&filter[PROPERTY_CODE]=тип
function getIblockElementsByProperty($iblockId, $propertyCode, $propertyValue)
{
$result = [];
$iblockElements = CIBlockElement::GetList(
['ID' => 'ASC'],
['IBLOCK_ID' => $iblockId],
false,
['ID', 'IBLOCK_ELEMENT_PROPERTIES']
);
while ($iblockElement = $iblockElements->GetNext()) {
foreach ($iblockElement['PROPERTIES'] as $property) {
if ($property['CODE'] === $propertyCode && $property['VALUE'] === $propertyValue) {
$result[] = $iblockElement;
break;
}
}
}
return $result;
}
const AWS = require('aws-sdk');
const lambda = new AWS.Lambda();
const params = {
FunctionName: 'YourLambdaFunctionName',
InvocationType: 'RequestResponse', // Используйте 'Event' для асинхронного вызова
Payload: JSON.stringify({ key: 'value' }) // Передайте данные в вашу Lambda-функцию
};
lambda.invoke(params, function (err, data) {
if (err) {
console.error(err, err.stack);
} else {
console.log(data);
}
});
import telebot
import multiprocessing
# Tokens
bot1_token = '8853281015:Wfw_232rrfzwuQIduiqyuf212_8d7yuw124'
bot2_token = '5730985673:WHt_37aj24Adh28Wf27fwqi_248228524'
def bot1_listener():
bot1 = telebot.TeleBot(bot1_token)
@bot1.message_handler(commands=["x"])
def start(m, res=False):
bot1.send_message(m.chat.id, '123')
bot1.polling(none_stop=True, interval=0)
def bot2_listener():
bot2 = telebot.TeleBot(bot2_token)
# Define your message handlers for bot2 here
bot2.polling(none_stop=True, interval=0)
if __name__ == "__main__":
process1 = multiprocessing.Process(target=bot1_listener)
process2 = multiprocessing.Process(target=bot2_listener)
# Start the bot processes
process1.start()
process2.start()
process1.join()
process2.join()
import { Repository, EntityRepository } from 'typeorm';
import { PaginationDto } from './pagination.dto';
@EntityRepository(YourEntity)
export class YourEntityRepository {
constructor() {
super(YourEntity);
}
async getAllTutors(identification_post: string, dto: PaginationDto) {
const query = this.createQueryBuilder('yourEntityAlias'); // Замените 'yourEntityAlias' на алиас вашей сущности
query.where('post_text ILIKE :keyword', { keyword: `%${identification_post}%` });
const [results, total] = await query
.take(dto.limit)
.skip((dto.page - 1) * dto.limit)
.getManyAndCount();
return { results, total };
}
}
public static function OnAfterIndexAddExtended($searchContentId, &$fields)
{
if (
$fields['MODULE_ID'] !== 'iblock' ||
!$fields['ITEM_ID'] ||
!in_array($fields['PARAM2'], self::$Iblock)
) {
return;
}
// Удалите поле 'TITLE' из массива $fields
unset($fields['TITLE']);
// Получите внешний код раздела из какого-то другого источника, например, из базы данных
$externalCode = getExternalCodeForElement($fields['ITEM_ID']);
// Добавьте внешний код к полю 'b_search_content_title'
$fields['b_search_content_title'] .= ' ' . $externalCode;
// Обновите индекс для измененной записи
\CSearchFullText::getInstance()->replace($searchContentId, $fields);
}
import asyncio
import logging
import time
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
from aiogram import Bot, Dispatcher, MemoryStorage
from config import config
import Handlers
from sqlFile import db, sql, create_sql
class MyHandler(PatternMatchingEventHandler):
patterns = ["*.txt", "*.jpg"]
def process(self, event):
out = str(event.src_path)
with open(out, "r") as t1:
text = t1.read()
print(out)
print(text)
def on_modified(self, event):
self.process(event)
def on_created(self, event):
self.process(event)
async def observer_run():
args = 'C:\\ForTest'
observer = Observer()
observer.schedule(MyHandler(), path=args if args else '.')
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
async def main():
bot = Bot(token=config['token'], parse_mode="HTML")
storage = MemoryStorage()
dp = Dispatcher(storage=storage)
logging.basicConfig(level=logging.INFO)
create_sql()
dp.include_router(Handlers.user_router)
await bot.delete_webhook(drop_pending_updates=True)
await dp.start_polling(bot)
if __name__ == "__main__":
asyncio.run(asyncio.gather(main(), observer_run()))
const root = ReactDOM.createRoot(document.getElementById('root'));
const container = ReactDOM.createContainer(document.getElementById('root'), false, false);
ReactDOM.updateContainer(element, container, null, () => {
// Callback, который вызывается после завершения обновления
});
const fiberRoot = ReactDOM.createFiberRoot(container, false);
// На сервере Express.js
app.post('/some-route', (req, res) => {
// Обработка данных и отправка их клиенту
const dataToSend = { message: 'Данные успешно получены' };
res.json(dataToSend);
});
// На клиенте (JavaScript)
fetch('/some-route', {
method: 'POST',
body: JSON.stringify({ /* данные для отправки */ }),
headers: {
'Content-Type': 'application/json'
}
})
.then(response => response.json())
.then(data => {
// Рендеринг данных на стороне клиента
const messageElement = document.getElementById('message');
messageElement.innerText = data.message;
})
.catch(error => console.error(error));
add_action('wpcf7_before_send_mail', 'custom_wpcf7_add_to_cart');
function custom_wpcf7_add_to_cart($form) {
// Получите данные из формы
$product_id = intval($_POST['your-product-id']); // Замените на имя поля для ID товара
$quantity = intval($_POST['your-product-quantity']); // Замените на имя поля для количества товара
// Проверьте, что товар существует в WooCommerce
if (wc_get_product($product_id)) {
// Добавьте товар в корзину
WC()->cart->add_to_cart($product_id, $quantity);
}
}
#include <iostream>
#include <cuda_runtime.h>
__global__ void generateHexString(char* result, int* array)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
result[idx] = array[idx];
}
int main()
{
const int arraySize = 16;
char array[arraySize] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
char result[arraySize];
char* d_result;
int* d_array;
cudaMalloc((void**)&d_result, arraySize * sizeof(char));
cudaMalloc((void**)&d_array, arraySize * sizeof(int));
cudaMemcpy(d_array, array, arraySize * sizeof(int), cudaMemcpyHostToDevice);
int threadsPerBlock = 16;
int blocksPerGrid = 1;
generateHexString<<<blocksPerGrid, threadsPerBlock>>>(d_result, d_array);
cudaMemcpy(result, d_result, arraySize * sizeof(char), cudaMemcpyDeviceToHost);
cudaFree(d_result);
cudaFree(d_array);
std::cout << "Generated hex string: " << result << std::endl;
return 0;
}