def test_have_expired_item(self):
tst_usr1 = classes.User('Memur', 10013, 'User1', 3, 0, 1,
'*****@*****.**') # Borca girmiş bir kişi seçilmiştir
tst_usr2 = classes.User(
'Öğretim Görevlisi', 10018, 'User2', 6, 0, 2,
'*****@*****.**') # Borcu olmayan bir kişi seçilmiştir
self.assertTrue(db.have_expired_item(tst_usr1))
self.assertFalse(db.have_expired_item(tst_usr2))
def test_control_get_operation(self):
tst_usr1 = classes.User('Memur', 1, 'User1', 3, 0, 1, '*****@*****.**')
tst_usr2 = classes.User('Öğretim Görevlisi', 2, 'User2', 6, 0, 2,
'*****@*****.**')
tst_usr3 = classes.User('Öğrenci', 3, 'User3', 0, 0, 3, '*****@*****.**')
self.assertFalse(db.control_get_operation(
tst_usr1)) # Memur maksimum 3 kitap alabilir fazlasını alamaz
self.assertFalse(
db.control_get_operation(tst_usr2)
) # Öğretim Görevlisi maksimum 6 kitap alabilir fazlasını alamaz
self.assertTrue(db.control_get_operation(
tst_usr3)) # Öğrenci maksimum 3 kitap alabilir şuan kitap alabilir
def filterTweets(json_data, name):
full = json.load(json_data)
filtered = {}
filtered["id_str"] = full["id_str"]
filtered["created_at"] = full["created_at"]
filtered["retweet_count"] = full["retweet_count"]
filtered["favorite_count"] = full["favorite_count"]
filtered["text"] = full["text"]
words = re.sub("(@[A-Za-z0-9]+)|([^0-9A-Za-z \t])|(\w+:\/\/\S+)"," ",full["text"].lower()).split()
bagOfWords = {}
for word in words:
if word not in stopwords.words("english") and word !="rt":
if word in bagOfWords:
bagOfWords[word] +=1;
else:
bagOfWords[word] = 1;
filtered["bag_of_words"] = bagOfWords
entities = classes.Entities(full["entities"])
filtered["entities"] = entities
user = classes.User(full["user"])
filtered["user"] = user
output = open(filtereddir + "filtered" + name, "w+")
json.dump(filtered, output, default = jdefault)
def starter():
test_user = classes.User(settings.user_id, settings.user_token)
print('Входные данные.')
print(f'Имя или ID пользователя: {test_user.user_id}')
print(f'Токен пользователя: {test_user.token}')
print(
f'Максимальное количество друзей в группе: {settings.max_friends_in_group}'
)
print('Начало работы.')
test_user.check_user_id()
print('Входные данные проверены.')
test_user.get_friends()
print('Список друзей пользователя получен.')
test_user.get_groups()
print('Список групп пользователя получен.')
unique_groups = []
groups_count = 0
friends_count = 0
percent = 0
for group in test_user.groups:
groups_total = len(test_user.groups)
found = 0
friends = ''
print(
f"[{'*' * (percent // 10)}{' ' * (10 - percent // 10)}] Проанализировано {percent}% групп."
)
for friend in test_user.friends:
friends = friends + str(friend) + ','
friends_count += 1
if friends_count == 500:
found += find_friends_in_group(test_user, friends, group)
friends = ''
friends_count = 0
found += find_friends_in_group(test_user, friends, group)
if found <= settings.max_friends_in_group:
unique_groups.append(group)
groups_count += 1
percent = round(groups_count / groups_total * 100)
print(f"[{'*' * 10}] Проанализировано 100% групп.")
if len(unique_groups) == 0:
print(
'Групп, удовлетворяющих условиям не найдено.\nСоздан пустой файл.')
file = open('groups.json', 'w')
file.close()
else:
print('Следующие группы удовлетворяют условиям:')
groups_output(unique_groups)
with open('groups.json', 'w', encoding='utf-8') as file:
json.dump(unique_groups, file, indent=2, ensure_ascii=False)
print('Данные записаны в файл.')
def extractUsers(json_data): full = json.load(json_data) user = classes.User(full["user"]) name = user.name if name not in names: names.append(name)
def startup(client):
logpath = "./logs"
if not os.path.isdir(logpath):
print("Log folder not found")
print("Creating directory")
os.makedirs(logpath)
print("Log directory created, creating log files")
try:
with open(keys.chandir, "x") as f:
print("Channel log created")
except FileExistsError:
print("Channel log already exists")
print("- Channels")
try:
with open(keys.chandir, "x") as f:
print("User log created")
except FileExistsError:
print("User log already exists")
print("- Users")
print("File creation complete")
print("----------")
# Check the log files exist, if not then create
try:
with open(keys.chandir, "x") as f:
print("Channel log created")
except FileExistsError:
print("Channel log found")
try:
with open(keys.userdir, "x") as f:
print("User log created")
except FileExistsError:
print("User log found")
print("----------")
# User list update/population
# First loop through each server the bot is a part of, and pick out the specific server we want
for s in client.servers:
if s.id == keys.serverid:
dbfile = {}
dblive = {}
for user in s.members:
dblive[user.id] = c.User(user.id)
dblive[user.id].name = user.name
dblive[user.id].id = user.id
if os.stat(keys.userdir).st_size == 0:
print("User log empty, populating...")
with open(keys.userdir, "wb") as f:
pickle.dump(dblive, f)
with open(keys.userdir, "rb") as f:
dbfile = pickle.load(f)
for u in dbfile:
if dbfile[u].name != dblive[u].name:
dbfile[u].name = dblive[u].name
with open(keys.userdir, "wb") as f:
pickle.dump(dbfile, f)
print("User update complete")
print("----------")
async def send_welcome(message: types.Message):
users[str(message.from_user.id)] = classes.User(message.from_user.id)
if(users[str(message.from_user.id)].IsInBase(message.from_user.id)):
if(users[str(message.from_user.id)].IsAdmin()):
await message.answer("Привет, я бот библиотекарь, созданный силами студентов ФИИТа и самого бога. ФИИТ ТОП!",reply_markup=kb.AdminKeybord())
else:
await message.answer("Привет, я бот библиотекарь, созданный силами студентов ФИИТа и самого бога. ФИИТ ТОП!",reply_markup=kb.StandartKeybord())
else:
await message.answer("Привет, я бот библиотекарь, созданный силами студентов ФИИТа и самого бога. ФИИТ ТОП! \nТеперь укажите своё направление подготовки и курс.",reply_markup=kb.StartKeybord())
def main_loop():
user = classes.User()
while True:
if user.auth == 0:
show_menu(0)
else:
show_menu(1)
handler(user)
async def get_user(conn, device_id):
if not device_id:
return None
with conn.cursor() as cursor:
cursor.execute('SELECT * FROM users WHERE device_id=%s', device_id)
raw_user = cursor.fetchone()
if raw_user:
return cl.User().unmarshall(raw_user)
return None
def __init__(self):
super(myRecord, self).__init__()
self.account = None
self.setupUi(self)
self.recordTableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers) # 设置不可编辑
self.recordTableWidget.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.user = classes.User()
self.load()
self.tableShow()
bg = QtGui.QPalette()
bg.setBrush(self.backgroundRole(), QtGui.QBrush(QtGui.QPixmap("myRecordWindow.jpg"))) # 设置背景图片
self.setPalette(bg)
def b_user_change_click(self):
name = self.in_name.text()
surname = self.in_surname.text()
e_mail = self.in_email.text()
phonenumber = self.in_phone.text()
location = self.cb_location_u.currentText()
password_1 = self.in_password1.text()
password_2 = self.in_password2.text()
if password_1 == "" and self.logged_in_user:
password_1 = False # leave password as it
password_2 = False
locals_ = {
key: value
for (key, value) in locals().items() if key != "self"
}
if "" in locals_.values():
self.not_all_fields_filled_notice()
return
if password_1 != password_2:
self.status_bar_text("Die Passwörter stimmen nicht überein", 5,
"red")
return
else:
password = password_1
if self.logged_in_user:
user = self.logged_in_user
else:
user = classes.User(e_mail, password)
with CSession() as session:
session.add(user)
location = session.query(
classes.Location).filter_by(name=location).first()
user.name = name
user.surname = surname
user.e_mail = e_mail
user.phonenumber = classes.PhoneNumber(phonenumber)
user.location = location
if self.logged_in_user and password:
user.hash(password)
if self.logged_in_user:
self.logged_in_user = user
logger.info(f"User {user} changed through UI")
self.status_bar_text(f"Benutzer {user} wurde erfolgreich geändert",
5, "green")
else:
self.status_bar_text(f"Benutzer {user} wurde erfolgreich angelegt",
5, "green")
logger.info(f"User {user} created through UI")
def test_control_get_book(self):
tst_usr1 = classes.User('Memur', 1, 'User1', 0, 0, 1, '*****@*****.**')
tst_usr2 = classes.User('Öğretim Görevlisi', 2, 'User2', 0, 0, 2,
'*****@*****.**')
tst_usr3 = classes.User('Öğrenci', 3, 'User3', 0, 0, 3, '*****@*****.**')
tst_item1 = classes.Stock('Kitap', 'Ders', 'Kitap İsmi',
'Sercan Aksoy', 1, '2020-10-10', 'BCDA',
True)
tst_item2 = classes.Stock('Kitap', 'Bilim', 'Kitap İsmi2',
'Sercan Aksoy', 1, '2020-10-10', 'BCDA',
True)
self.assertFalse(db.control_get_book(
tst_usr1,
tst_item1)) # Öğretim Görevlisi dışında biri Ders Kitabı alamaz
self.assertTrue(db.control_get_book(
tst_usr2, tst_item1)) # Öğretim Görevlisi Ders Kitabı alabilir
self.assertTrue(
db.control_get_book(tst_usr3, tst_item2)
) # Öğretim Görevlisi dışında biri Ders Kitabı harici kitap alabilir
def __init__(self):
super(userWindow, self).__init__()
self.account = None
self.setupUi(self)
self.userTableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers) # 设置不可编辑
self.userTableWidget.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.child = myRecord() # 子窗口实例化
self.user = classes.User()
self.load()
bg = QtGui.QPalette()
bg.setBrush(self.backgroundRole(), QtGui.QBrush(QtGui.QPixmap("userWindow.jpg"))) # 设置背景图片
self.setPalette(bg)
self.userTableWidget.horizontalHeader().sectionClicked.connect(self.HorSectionClicked)
self.lending = 0
self.left = 0
def add_other_conf():
new_id = functions.get_id_staff_increment()
pw = request.form['password'] + request.form['email']
user = classes.User(id=new_id,
username=request.form['username'],
password=hashlib.md5(pw.encode()).hexdigest(),
nome=request.form['nome'],
cognome=request.form['cognome'],
email=request.form['email'],
datanascita=request.form['dataNascita'])
other = classes.Other(id=new_id)
session.add(user)
session.add(other)
session.commit()
return redirect(url_for('confirm'))
async def retrieve_user(data, conn):
user = cl.User(name=data.get('name'),
phone=data.get('phone'),
fcm_token=data.get('fcmToken'),
device_id=data.get('deviceId'),
os=data.get('os'),
app_version=data.get('appVersion'),
region=data.get('region'),
language=data.get('language'),
os_version=data.get('osVersion'))
db_user = await db.get_user(conn=conn, device_id=user.device_id)
if db_user:
user = db_user.update(user)
return user
def create_admin():
exists = session.query(classes.Other).filter(classes.Other.id == 0).first()
if not exists:
new_id = 0
pw = 'admin' + '*****@*****.**'
user = classes.User(id=new_id,
username="******",
password=hashlib.md5(pw.encode()).hexdigest(),
nome="admin",
cognome="admin",
email="*****@*****.**",
datanascita='1000-01-01')
admin = classes.Other(new_id)
session.add(user)
session.add(admin)
session.commit()
def COMREGISTER(ClientInfo:ClientInformation, Login, Password, ConfirmPassword):
if len(Login) > 15:
return (Inf.Error, '15', ClientInfo.language.LoginLength)
if not variables.REGISTRATION and ClientInfo.CurrentUser.UserRole != variables.ADMINISTRATORROLE:
return (Inf.Error, 'REGISTERNOTAVAIBLE', ClientInfo.language.RegistrationIsNotAvaible)
if Password != ConfirmPassword:
return (Inf.Error, 'PASSWORDSDONOTMATCH', ClientInfo.language.PasswordsDoNotMatch)
HashPassword = funs.EncryptString(Password)
RegUser = classes.User(Login, HashPassword, variables.REGISTRATIONROLE, variables.MAXIMUMCREATEDATABASE)
Complete = usersdb.CreateUser(RegUser)
Message = ClientInfo.language[Complete]
if Complete == 'NotCorrectLoginUser':
return (Inf.Error, 'NOTCORRECTLOGINUSER', Message)
if Complete == 'UserIsExists':
return (Inf.Error, 'USEREXISTS', Message)
return (Inf.OK, ClientInfo.language.NA, Message)
def __init__(self):
self.serialVersionUID = 1260045197860645956L
self.lmsName = "IITEDX"
self.db = None
self.cursor = None
self.studentCourseEnrolment = classes.Studentcourseenrolment
self.stateDao = None
self.state = classes.States()
self.mongoDateFormat = ""
#// private EventCourseInteractDao eventCourseInteractDao = null
#// private EventProbInteractDao eventProbInteractDao = null
#// private EventVideoInteractDao eventVideoInteractDao = null
#private UserSessionOldDao userSessionDao = null
self.eventId = -1
self.eventProbInteract = classes.Eventprobinteract()
self.answers = ''
self.eventVideoInteract = classes.Eventvideointeract()
self.eventCourseInteract = classes.Eventcourseinteract()
self.userSession = classes.Usersessionold()
self.moduleType = ""
self.moduleId = ""
self.stateStr = ""
self.key = ""
self.inputkeys = []
self.currSeekTime = 0.0
self.city = classes.Cities()
self.tmpStrArr = []
self.keySet = []
self.evnt_Save_Video_Position = 0
self.recNo = 0
self.firstFlag = 0
self.user = classes.User()
self.currEventNo = 0
self.birthDatefrmt = ""
self.dsf = "{%H:%M:%S}"
self.tmpDate = ""
self.getLastId = None
self.itr1 = None
self.itr2 = None
self.properties = {}
self.propertyFile = "EdxParams.properties"
self.correctMapJson = None
self.studentAnswerJson = None
self.correctMapKeyValJson = None
'''private PreparedStatement psVideo = null, psVideoInteract = null,
def comment(bot, update):
user = update.message.from_user
new_user = classes.User(username=user.username,
first_name=user.first_name,
last_name=user.last_name)
chat_id = update.message.chat_id
USERS.update({chat_id: new_user})
markup = ReplyKeyboardMarkup([['/cancel']], resize_keyboard=True)
update.message.reply_text(
'Вижу вы решили оставить <b>ГНЕВНЫЙ</b> комментарий?\n'
'Окей, я только за!\n\nМожете писать, все что хотите!\n'
'Доставку беру на себя)\n'
'Используйте /cancel для отмены',
quote=True,
parse_mode='HTML',
reply_markup=markup)
return MARK
def create_users(input_file, primary_key):
users_dict = {}
users_temp_dict = csv_to_dict(input_file, primary_key)
for itemid, attributes in users_temp_dict.items():
username = attributes['username']
user_type = attributes['user_type']
dim_factor = attributes['dim_factor']
itemid = classes.User(attributes['username'], attributes['itemid'],
attributes['instance_name'], attributes['lat'],
attributes['lon'], attributes['user_type'],
attributes['dim_factor'])
users_dict[username] = itemid
logging.debug(
'User %s (%s) created with dim_factor = %s\nWaste productionof %s: %s'
% (username, user_type, dim_factor, username,
itemid.details['waste_production']))
return users_dict
def test_get_user(self):
tst_usr = classes.User('Memur', 10020, 'Merve Ece Altınok', 1, 0,
10019, '*****@*****.**')
func_usr = db.get_user('10020')
self.assertIsInstance(
func_usr, classes.User
) # Getirilen objenin istenilen sınıfın objesi olup olmadığı
self.assertEqual(int(func_usr.user_id), tst_usr.user_id)
self.assertEqual(func_usr.name_surname, tst_usr.name_surname)
self.assertEqual(int(func_usr.card_id), tst_usr.card_id)
self.assertEqual(func_usr.email, tst_usr.email)
self.assertEqual(func_usr.category, tst_usr.category)
self.assertEqual(func_usr.owned_item, tst_usr.owned_item)
self.assertEqual(
func_usr.reserved_item, tst_usr.reserved_item
) # Getirilien objenin istenilen obje ile aynı özelliklere sahip olup olmadığı
async def apply_promo(conn, code, dev_id):
if not code:
raise cl.ClientError("Неверный промокод")
sql = 'SELECT * FROM users WHERE promo=%s'
with conn.cursor() as cursor:
cursor.execute(sql, code)
raw_user = cursor.fetchone()
if not raw_user:
raise cl.ClientError("Неверный промокод")
user = cl.User().unmarshall(raw_user)
if user.used_promo >= cl.Consts.total_promo():
raise cl.ClientError("Лимит активированных промокодов исчерпан")
try:
await add_promo_appliance(conn=conn, code=code, dev_id=dev_id)
except pymysql.IntegrityError:
raise cl.ClientError("Промокод дважды применен одним пользователем")
user.used_promo += 1
await update_user(conn, user)
def create_user():
new_id = functions.get_id_increment()
pw = request.form['password'] + request.form['email']
user = classes.User(id=new_id,
username=request.form['username'],
password=hashlib.md5(pw.encode()).hexdigest(),
nome=request.form['nome'],
cognome=request.form['cognome'],
email=request.form['email'],
datanascita=request.form['dataNascita'])
client = classes.Client(id=new_id)
session.add(user)
session.add(client)
if request.form[
'abb'] != "null": # controllo se è stato scelto oppure no un abbonamento
sub = functions.get_subscription(request.form['abb'])
if request.form['abb'] == 'prova':
subscriber = classes.Subscriber(
id=new_id,
abbonamento=sub.id,
datainizioabbonamento=functions.get_current_date(),
datafineabbonamento=functions.get_increment_date(7),
durata=7)
session.add(subscriber)
else:
subscriber = classes.Subscriber(
id=new_id,
abbonamento=sub.id,
datainizioabbonamento=functions.get_current_date(),
datafineabbonamento=functions.get_increment_date(
int(request.form['durata'])),
durata=request.form['durata'])
session.add(subscriber)
else:
not_subscriber = classes.NotSubscriber(id=new_id)
session.add(not_subscriber)
session.commit()
return redirect(url_for('confirm'))
def dot_algorithm(self, user_id, user_name, text, lang):
"""
This is main function. It make answer for user
:param user_id: unic user id
:param user_name:
:param text:
:param lang:
:return:
"""
# We have not talked yet
if user_id not in users_dict:
result = errors_code.get_error(7, lang) % user_name
users_dict[user_id] = classes.User(user_id, user_name, lang)
return result
user = users_dict[user_id]
if text[0] == '/':
# command
result = self.command(user, text)
else:
# answer
result = user.next_dialog(text)
return result
def login(e_mail, password):
"""Log user into application
Checks if there's a user of given name in the database,
if the given password is correct and returns the user if both is the case
Args:
e_mail (str): e_mail of the user that wants to log in
password (str): user provided password to check against
"""
e_mail = e_mail.lower()
with CSession() as session:
try:
user = session.query(classes.User).filter_by(e_mail=e_mail).first()
user_at_gate = classes.User(e_mail, password, salt=user.salt)
if compare_digest(user_at_gate.password, user.password):
session.expunge(user)
logger.info(f"Successfully logged in as {user.uid}")
return user
else:
logger.info(
f"Attempted login with wrong password for user {e_mail}")
return None
except (AttributeError, ValueError) as e: #user not found exception
logger.info(f"Attempted login from unknown user {e_mail}")
raise ValueError(f"Attemped login from unknown user {e_mail}")
def extractTweets(json_data): full = json.load(json_data) user = classes.User(full["user"]) tweet = classes.Tweet(user.name, full["bag_of_words"], full["id_str"]) tweets.append(tweet)
def create_admin(*args, **kwargs):
"""Create a new admin"""
new_admin = classes.User(*args, **kwargs)
new_admin.is_admin = True
return new_admin
from os.path import isfile
import pickle
import classes
import access
import variables
import language
import funs
# Работа с пользователями
ADMINISTRATOR = classes.User(variables.ADMINISTRATORNAME, variables.ADMINISTRATORPASSWORD, variables.ADMINISTRATORROLE, -1) # администратор по умолчанию
DEFAULTUSER = classes.User(variables.DEFAULTNAME, '', variables.DEFAULTROLE, 0) # пользователь по умолчанию для незарегистрированных пользователей
DEFAULTUSER.DataBases['GLOBAL'] = classes.AccessDataBase(True, False, True, False, False, True, False) # ему доступна по умолчанию база данных GLOBAL с возможностью чтения данных (добавляется для всех пользователей)
USERS = dict() # Переменная для хранения пользователей
# Инициализация базы данных
def InitializeUsers():
global USERS
if isfile(variables.USERSDATABASEFILE):
try:
with open(variables.USERSDATABASEFILE, 'rb') as f:
USERS = pickle.load(f)
except: # если база данных повреждена, спрашивается возможность пересоздать ее
print(language.SERVERLANG.CantOpenDatabaseUsers.format(variables.USERSDATABASEFILE))
print(language.SERVERLANG.DatabaseUsersCorrupt)
if funs.GetAnswer():
with open(variables.USERSDATABASEFILE, 'wb') as f:
pickle.dump(dict(), f)
else:
def get_user_by_email(email):
user = session.query(
classes.User).filter(classes.User.email == email).first()
return classes.User(user.id, user.username, user.password, user.nome,
user.cognome, user.email, user.datanascita)
def get_admin_user():
user = session.query(classes.User).filter(classes.User.id == 0).first()
return classes.User(user.id, user.username, user.password, user.nome,
user.cognome, user.email, user.datanascita)
