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')