def register(data, db_session):
valid_registering_intervall = value('valid_registering_intervall', 120)
logging.info(Msg.START + ' data is: ' + str(data))
cell_no = data.get('cell_no')
if cell_no is None:
logging.error(Msg.DATA_MISSING.format('cell_no'))
raise Http_error(404, Msg.DATA_MISSING.format('cell_no'))
logging.debug(Msg.CHECK_USER_EXISTANCE)
if check_user(cell_no, db_session):
logging.error(Msg.USER_XISTS)
raise Http_error(409, Msg.USER_XISTS)
logging.debug(Msg.CHECK_REDIS_FOR_EXISTANCE)
if redis.get(cell_no):
logging.error(Msg.REGISTER_XISTS)
raise Http_error(403, Msg.REGISTER_XISTS)
logging.debug(Msg.GENERATING_REGISTERY_CODE.format(cell_no))
password = random.randint(1000, 9999)
message = 'BELLEZZA your activation code is : {}'.format(password)
data = {'cell_no': cell_no, 'message': message}
logging.debug(Msg.SEND_CODE_BY_SMS.format(cell_no))
sent_data = send_message(data)
logging.debug(Msg.SMS_SENT.format(cell_no))
redis.set(cell_no, password, ex=valid_registering_intervall)
return sent_data
def forget_pass(data, db_session):
logger.info(LogMsg.START, data)
schema_validate(data, FORGET_PASS_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
reset_password_interval = value('reset_password_interval', 120)
username = data.get('username')
cell_no = data.get('cell_no')
user = None
if username:
user = check_by_username(username, db_session)
elif cell_no:
user = check_by_cell_no(cell_no, db_session)
else:
logger.error(LogMsg.INVALID_USER, data)
raise Http_error(400, Message.USERNAME_CELLNO_REQUIRED)
if user:
person = validate_person(user.person_id, db_session)
logger.debug(LogMsg.PERSON_EXISTS, username)
password = str(random.randint(1000, 9999))
sending_data = {
'receptor': person.cell_no,
'token': user.username,
'token2': password,
'type': 'sms',
'template': 'fajrresetPassword'
}
send_message(sending_data)
logger.debug(LogMsg.SMS_SENT, sending_data)
redis_key = 'PASS_{}'.format(person.cell_no)
redis.set(redis_key, password, ex=reset_password_interval)
logger.debug(LogMsg.REDIS_SET, redis_key)
logger.info(LogMsg.END)
return data
logger.error(LogMsg.INVALID_USER, data)
raise Http_error(404, Message.INVALID_USER)
import os
import subprocess
from helper import value, Http_error
from log import LogMsg, logger
from messages import Message
book_generator_app_address = value('book_generator_app_address', None)
if book_generator_app_address is None:
logger.error(LogMsg.APP_CONFIG_INCORRECT,
{'book_generator_app_address': None})
raise Http_error(500, Message.APP_CONFIG_MISSING)
def execute_process(data, username=None):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.RUN_PROCESS_DATA, data)
print("data={}".format(data))
arr = [book_generator_app_address]
arr.extend(data)
results = subprocess.Popen(arr, close_fds=True, stdout=subprocess.PIPE)
streamdata = results.communicate()[0]
if results.returncode != 0:
error = results.stderr
logger.error(LogMsg.BOOK_GENERATE_FAILED, error)
os.remove(data[0])
os.close()
raise Exception('process failed...')
logger.info(LogMsg.END)
return results.__dict__
import requests
from kavenegar import *
from helper import value, Http_error
from log import logger, LogMsg
from messages import Message
sms_token_url = value('sms_token_url', 'https://RestfulSms.com/api/Token')
sms_security_key = value('sms_security_key', 'Jame_jam@nsm5msd&*!')
sms_api_key = value('sms_api_key', '51493c0cc42cd23559c73c0c')
sms_timeout = value('sms_timeout', 20)
sms_send_url = value('sms_send_url', 'https://RestfulSms.com/api/MessageSend')
sms_line_no = value('sms_line_no', '10005195')
def send_message(data):
receptor = data.get('receptor')
if receptor.startswith('0999'):
data['receptor'] = '09357364928'
if sms_api_key is None:
logger.error(LogMsg.DATA_MISSING, {'sms_api_key': sms_api_key})
raise Http_error(400, Message.MISSING_REQUIERED_FIELD)
try:
api = KavenegarAPI(sms_api_key)
params = data
response = api.verify_lookup(params)
print(response)
logger.debug(LogMsg.MESSAGE_SENT, response)
except APIException as e:
logger.exception(LogMsg.MESSAGE_NOT_SENT, exc_info=True)
print(e)
from check_permission import get_user_permissions, has_permission
from configs import ADMINISTRATORS
from enums import OrderStatus, Permissions
from order.controllers.order_items import add_orders_items, \
delete_orders_items_internal
from repository.user_repo import check_user
from order.models import Order
from helper import Http_error, populate_basic_data, Http_response, \
model_to_dict, check_schema, edit_basic_data, value, model_basic_dict
from log import LogMsg, logger
from messages import Message
from user.controllers.person import get as get_person
administrator_users = value('administrator_users', ['admin'])
def add(data, db_session, username):
logger.info(LogMsg.START, username)
check_schema(['items'], data.keys())
user = check_user(username, db_session)
if user is None:
raise Http_error(400, Message.INVALID_USER)
if user.person_id is None:
logger.error(LogMsg.USER_HAS_NO_ACCOUNT, username)
raise Http_error(400, Message.Invalid_persons)
model_instance = Order()
import json
import os
from celery import Celery
from configs import CELERY_DATABASE_URI
from helper import value
from messages import Message
from run_process.call_process import execute_process
temprory_saving_path = value('temprory_saving_path', '/tmp')
book_saving_path = value('book_saving_path', '/home/nsm/book_sources')
app = Celery('jjp', backend=CELERY_DATABASE_URI,
broker='pyamqp://guest@localhost//')
app.config_from_object('celery_works.celeryconfig')
task_routes = {
'sms': {'queue': 'sms'},
'book_generate': {'queue': 'book_generate'}
}
@app.task(name='book_generate', bind=True)
def generate_book_content(self, data, **kwargs):
# TODO run process
json_file_name, out_file_name, final_file_name = save_json_file(data)
print('json_file_name, out_file_name, final_file_name ', json_file_name,
out_file_name, final_file_name)
from book_encription.controllers.device_key import user_device_exist
from book_library.controller import is_book_in_library
from books.controllers.book_content import get_be_data
from check_permission import get_user_permissions, has_permission, \
validate_permissions_and_access
from enums import Permissions
from helper import Http_error, value, check_schema
from log import LogMsg, logger
from infrastructure.schema_validator import schema_validate
from messages import Message
from ..constants import PREPARE_BOOK_SCHEMA_PATH
import os
from repository.user_repo import check_user
book_saving_path = value('book_saving_path', '/home/nsm/book_sources')
if book_saving_path is None:
logger.error(LogMsg.APP_CONFIG_INCORRECT, {'save_path': None})
raise Http_error(500, Message.APP_CONFIG_MISSING)
save_path = value('save_path', None)
if save_path is None:
logger.error(LogMsg.APP_CONFIG_INCORRECT, {'save_path': None})
raise Http_error(500, Message.APP_CONFIG_MISSING)
def prepare_book(data, db_session, username):
logger.info(LogMsg.START, username)
result = {}
schema_validate(data, PREPARE_BOOK_SCHEMA_PATH)
book_id = data.get('book_id')
import json
import logging
import os
from uuid import uuid4
from log import Msg
from helper import Now, model_to_dict, Http_error, value
from .model import Tag
admin = value('admin_username', 'admin')
def add(data, username, db_session):
if username != admin:
logging.error(Msg.NOT_ACCESSED)
raise Http_error(401, {'username': Msg.NOT_ACCESSED})
logging.info(Msg.START)
title = data.get('title')
if title is None:
logging.error(Msg.DATA_MISSING + ' title')
raise Http_error(400, {'title': Msg.DATA_MISSING})
tag = db_session.query(Tag).filter(
Tag.title == title).first()
if tag:
logging.error(Msg.NOT_UNIQUE + ' title already exists')
raise Http_error(409, {'title': Msg.NOT_UNIQUE})
model_instance = Tag()
from helper import Http_response, Http_error, value
from infrastructure.schema_validator import schema_validate
from log import logger, LogMsg
from messages import Message
MAX_DB_QUERY_LIMIT = value('MAX_DB_QUERY_LIMIT', 50)
class BasicController():
def __init__(self,
model,
repository_model,
schemas=None,
permissions=None):
self.model = model
self.repository = repository_model
self.schemas = schemas
self.permissions = permissions
def add(self,
data,
db_session,
username=None,
schema_checked=False,
permission_checked=False,
access_level=None,
special_data=None):
logger.debug(LogMsg.START, username)
repository_ins = self.repository.generate(self.model, db_session,
username)
logger.info(LogMsg.START, username)
import json
from enums import Permissions
from helper import Http_error, value
from log import logger, LogMsg
from messages import Message
from permission.controllers.group_permission import \
get_permission_list_of_groups
from permission.controllers.permission import get_permissions_values
from repository.group_user_repo import get_user_group_list
from repository.user_repo import check_user
from app_redis import app_redis
permission_list_expiration_time = value('permission_list_expiration_time', 60)
def has_permission(func_permissions, user_permission_list, model_instance=None,
data=None):
if any(permission.value in user_permission_list for permission in func_permissions):
return True
elif data is not None and data.get(Permissions.IS_OWNER.value,
False) is True:
return True
logger.error(LogMsg.NOT_ACCESSED, {'permission': 'not_found'})
logger.error(LogMsg.PERMISSION_DENIED)
raise Http_error(403, Message.ACCESS_DENIED)
def has_permission_or_not(func_permissions, user_permission_list, model_instance=None,
data=None):
from check_permission import get_user_permissions, has_permission
from enums import Permissions
from financial_transactions.controller import internal_add as transaction_add
from helper import Http_error, value, check_schema, populate_basic_data, \
model_to_dict, edit_basic_data
from log import logger, LogMsg
from messages import Message
from payment.controllers.payment import add_payment
from .payment import get as get_payment
from repository.account_repo import edit_persons_main_account
from repository.user_repo import check_user
from payment.KipoKPG import KipoKPG
from bottle import HTTPResponse
merchant_key = value('kipo_merchant_key', None)
if merchant_key is None:
logger.error(LogMsg.PAYMENT_FAILED_KIPO, {'merchant_key': merchant_key})
raise Http_error(400, Message.PAYMENT_FAILED)
kipo = KipoKPG(merchant_key)
base_url = value('app_server_address', '')
def pay_by_kipo(data, db_session, username):
logger.info(LogMsg.START, username)
check_schema(['amount'], data.keys())
logger.debug(LogMsg.SCHEMA_CHECKED)
from send_message import send_message
from user.urls import call_router as user_routes
from post.urls import call_router as post_routes
from app_token.urls import call_router as token_routes
from like.urls import call_router as like_routes
from comment.urls import call_router as comment_routes
from register.urls import call_router as register_routes
from category.urls import call_router as category_routes
from tag.urls import call_router as tag_routes
from direct_message.urls import call_router as direct_routes
from event.urls import call_router as event_routes
from helper import value
app_host = value('app_host', 'localhost')
app_port = value('app_port', '8080')
if __name__ == '__main__':
app = Bottle()
user_routes(app)
post_routes(app)
token_routes(app)
like_routes(app)
comment_routes(app)
register_routes(app)
category_routes(app)
tag_routes(app)
direct_routes(app)
import logging
import gammu
from helper import value
sm = gammu.StateMachine()
sm.ReadConfig()
port = value('app_port', 8080)
if port == '7000':
sm.Init()
logging.info('sms engine initiated')
print('sms engine initiated')
def send_message(data):
message = {
'Text': str(data.get('message')),
'SMSC': {
'Location': 1
},
'Number': str(data.get('cell_no'))
}
sm.SendSMS(message)
return data
from celery_works.celery_consumers import generate_book_content
from celery.result import AsyncResult
from check_permission import get_user_permissions, has_permission_or_not, \
has_permission, validate_permissions_and_access
from enums import Permissions
from helper import Http_error, value
from books.controllers.book_content import get_internal as get_content
from books.controllers.content_path_finder import return_content_full_path
from infrastructure.schema_validator import schema_validate
from log import logger, LogMsg
from messages import Message
from repository.book_repo import get as get_book
from .constants import GENERATE_BOOK_SCHEMA_PATH
book_saving_path = value('book_saving_path', '/home/nsm/book_sources')
if book_saving_path is None:
logger.error(LogMsg.APP_CONFIG_INCORRECT, {'save_path': None})
raise Http_error(500, Message.APP_CONFIG_MISSING)
def generate_book( data,db_session,username):
logger.info(LogMsg.START,username)
schema_validate(data,GENERATE_BOOK_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
content_id = data.get('content_id')
content = get_content(content_id, db_session)
if content is None:
logger.error(LogMsg.NOT_FOUND,{'book_content_id':content_id})
def _model(X_train, y_train, X_test, y_test):
class h_loss(keras.callbacks.Callback):
def on_train_begin(self, logs={}):
self.losses = [1, 1]
def on_epoch_end(self, batch, logs={}):
self.losses.append(logs.get('loss'))
def step_decay(losses):
if float(2 * np.sqrt(np.array(history.losses[-1]))) < derivative:
learning_rate = 0.001
momentum = 0.07
d_rate = 0.0
return learning_rate
else:
learning_rate = l_rate
return learning_rate
reward = 0
hidden = 8
n_hidden = 0
derivative = .25
threshold = .8
acc = 0.6
acc_list = [0, 0]
d_rate = 5e-6
momentum = 0.9
batch = 90
while acc - acc_list[-2] > 0.0001:
if reward == 0:
def model(nodes, l_rate, d_rate, momentum):
return helper.model1(nodes, l_rate, d_rate, momentum)
hidden_layers = 2
else:
def model(nodes, l_rate, d_rate, momentum):
return helper.model2(nodes, l_rate, d_rate, momentum)
hidden_layers = 1
history = h_loss()
learning_rate = LearningRateScheduler(step_decay)
l_rate, n_hidden, epochs = helper.value(reward, hidden, n_hidden)
model = model(n_hidden, l_rate, d_rate, momentum)
model.fit(X_train,
y_train,
nb_epoch=epochs,
batch_size=batch,
callbacks=[history, learning_rate])
d = model.evaluate(X_train, y_train, batch_size=batch)
reward = 1 - d[-1]
y_pred = model.predict(X_test, batch_size=batch)
acc = 1 - np.mean(abs(np.array([float(i) for i in y_pred]) - y_test))
acc_list.append(acc)
model.summary()
from bottle import static_file, response
from helper import file_mime_type, value
save_path = value('save_path')
def return_file(filename, **kwargs):
response.body = static_file(filename, root=save_path)
file_path = save_path + '/' + filename
response.content_type = file_mime_type(file_path)
return response
from uuid import uuid4
from infrastructure.schema_validator import schema_validate
from log import LogMsg, logger
from helper import Now, Http_error, value
from messages import Message
from .models import APP_Token
from .constants import ADD_SCHEMA_PATH
token_expiration_interval = value('token_expiration_interval', '1200')
new_token_request_valid_interval = value('new_token_request_valid_interval',
'30')
def add(db_session, data, username):
logger.info(LogMsg.START, username)
schema_validate(data, ADD_SCHEMA_PATH)
logger.debug(LogMsg.CHECKING_VALID_TOKEN, username)
current_token = get_current_token(db_session, username)
if current_token is not None and \
current_token.expiration_date > (Now()):
logger.debug(LogMsg.USER_HAS_VALID_TOKEN, current_token.id)
return current_token
model_instance = APP_Token()
model_instance.id = str(uuid4())
model_instance.username = username
model_instance.expiration_date = Now() + int(token_expiration_interval)
import json
import random
from uuid import uuid4
from helper import Http_error, value
from log import LogMsg, logger
from app_redis import app_redis as redis
from repository.person_repo import validate_person
from send_message.send_message import send_message
from infrastructure.schema_validator import schema_validate
from repository.user_repo import check_by_cell_no, check_by_username
from messages import Message
from .constants import REGISTER_SCHEMA_PATH, FORGET_PASS_SCHEMA_PATH, \
ACTIVATE_ACCOUNT_SCHEMA_PATH
valid_activating_intervall = value('valid_activating_intervall', 86400)
valid_registering_intervall = value('valid_registering_intervall', 200)
def app_ping():
return {"result": "app is on"}
def activate_account(data, db_session):
logger.info(LogMsg.START, data)
schema_validate(data, ACTIVATE_ACCOUNT_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
cell_no = data.get('cell_no')
import os
from uuid import uuid4
import magic
from bottle import response, static_file
from helper import value, Http_error, Http_response
from infrastructure.schema_validator import schema_validate
from log import logger, LogMsg
from messages import Message
from .constants import UPLOAD_SCHEMA_PATH, DELETE_SCHEMA_PATH
save_path = value('save_path', None)
def upload_files(data, **kwargs):
# schema_validate(data,UPLOAD_SCHEMA_PATH)
try:
files_list = data.get('files')
model_files = []
if files_list and len(files_list) > 0:
for file in files_list:
if file:
file.filename = str(uuid4())
model_files.append(file.filename)
file.save(save_path)
return model_files
except:
logger.exception(LogMsg.UPLOAD_FAILED, exc_info=True)
from check_permission import get_user_permissions, has_permission, \
validate_permissions_and_access
from enums import Permissions, Access_level
from helper import Http_error, value, populate_basic_data, edit_basic_data, \
model_to_dict, Http_response, check_schema
from infrastructure.schema_validator import schema_validate
from log import LogMsg, logger
from messages import Message
from repository.user_repo import check_user
from ..models import DeviceCode
from ..constants import DEVICE_KEY_SCHEMA_PATH
from random import randint
from base64 import b64encode
active_device_per_user = value('active_device_per_user', None)
if active_device_per_user is None:
logger.error(LogMsg.APP_CONFIG_INCORRECT, {'active_device_per_user': None})
raise Http_error(500, Message.APP_CONFIG_MISSING)
def add(data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data, DEVICE_KEY_SCHEMA_PATH)
user = check_user(username, db_session)
if user is None:
logger.error(LogMsg.INVALID_USER, username)
raise Http_error(404, Message.INVALID_USER)
user_id = user.id
if 'user_id' in data.keys():
user_id = data.get('user_id')
