def get_userby_name(name):
logging.info('user name db call')
user = Users.query.filter_by(name=name).first()
logging.info('user name db call success')
if user is not None:
logging.info('user name exiting')
return wrapper.wrapper(to_json(user), "Get user by id.", 200), 200
else:
logging.info('user name exiting')
return wrapper.wrapper(None, "User not found", 201), 201
if request.method == 'PUT':
logging.info('user name put menthod')
update_user = request.get_json()
user.name = update_user['name']
user.email = update_user['email']
user.phone = update_user['phone']
user.user_type = update_user['user_type']
try:
db.session.commit()
print(update_user)
logging.info('user name put menthod exiting')
return wrapper.wrapper(None, "success updated user data",
201), 201
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
logging.info('user name put menthod exiting')
db.session.rollback()
return wrapper.wrapper(None, e.message, 500), 500
def get_user(id):
logging.info('get user by id start and db call')
user = Users.query.filter_by(id=id).first()
logging.info('get user by id start and db call success')
if user is not None:
logging.info('get user by id exiting')
return wrapper.wrapper(to_json(user), "Get user by id.", 200), 200
else:
logging.info('get user by id exiting')
return wrapper.wrapper(None, "User not found", 201), 201
def create_user_representative():
if request.method == 'POST':
json_data = request.json
logging.info('create representative user post ')
token = uuid.uuid4()
user_type = UserType.REPRESENTATIVE
user_group = GroupName.GROUP2
model_user = Users(json_data,
confirmed=False,
token=token,
user_type=user_type,
user_group=user_group)
addr = Address(json_data['address'])
# sar = Sar(json_data['sar'])
# model_user.sar.append(sar)
model_user.address.append(addr)
db.session.add(model_user)
try:
try:
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
confirm_url = url_for('user.confirm_email',
token=token,
_external=True)
html = render_template(
'verification-email.html',
confirm_url=confirm_url,
name=json_data['name'],
company=current_app.config['DEFAULT_COMPANY_NAME'])
subject = "Please confirm your email"
sendMail(subject, json_data['email'], html)
# send_mail.send_email(json_data['email'], subject, html)
logging.info('create representative user post exiting')
return wrapper.wrapper(None,
"Representative user created successfully",
201), 201
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
logging.info('create representative user post exiting')
return wrapper.wrapper(None, e.message, 500), 500
if request.method == 'GET':
logging.info('create representative user post and db call')
get_users = Users.query.all()
logging.info('create representative user post and db call success')
all_users = []
for user in get_users:
for i in user.address.all():
print("pincode-->", i.pincode)
all_users.append(user.to_dict())
logging.info('create representative user post exiting')
return wrapper.wrapper(all_users, None, 200), 200
def get_ticket_info(id):
logging.info('put ticket-info db call start')
update_ticket_info = TicketInfo.query.filter_by(id=id).first()
logging.info('put ticket-info db success')
if request.method == 'GET':
logging.info('put ticket-info start')
if update_ticket_info is not None:
user_data = update_ticket_info.to_dict()
logging.info('put ticket-info Exiting')
return wrapper.wrapper(user_data, None, 200), 200
else:
logging.info('put ticket-info Exiting')
return wrapper.wrapper(None, "user not found", 204), 204
def get_department(id):
logging.info('get user by id db call')
user = Users.query.filter_by(id=id).first()
address = Address.query.filter_by(user_id=id).first()
logging.info('get user by id db call success')
if request.method == 'PUT':
logging.info('get user by id put method')
if user is not None:
update_user = request.get_json()
user.name = update_user['name']
user.email = update_user['email']
user.phone = update_user['phone']
user.user_type = update_user['user_type']
try:
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
address.addressline1 = update_user['address']['addressline1']
address.addressline2 = update_user['address']['addressline2']
address.pincode = update_user['address']['pincode']
address.city = update_user['address']['city']
address.country = update_user['address']['country']
address.state = update_user['address']['state']
try:
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
print(update_user)
logging.info('get user by id exiting')
return wrapper.wrapper(None, "success updated user data",
201), 201
else:
logging.info('get user by id exiting')
return wrapper.wrapper(None, "User not found", 201), 201
if request.method == 'DELETE':
logging.info('delete user by id start')
if user is not None:
try:
db.session.delete(user)
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
logging.info('delete user by id exiting')
return make_response(jsonify("Successfully deleted")), 204
else:
logging.info('delete user by id exiting')
return make_response("User not found"), 204
def get_ticket(id):
update_ticket = Ticket.query.filter_by(id=id).first()
if request.method == 'GET':
logging.info('get ticket start')
if update_ticket is not None:
user_data = update_ticket.to_dict()
logging.info('get ticket start Exiting')
return wrapper.wrapper(user_data, None, 200), 200
else:
logging.info('get ticket start Exiting')
return wrapper.wrapper(None, "user not found", 204), 204
if request.method == 'PUT':
logging.info('put ticket start')
up_ticket = request.get_json()
update_ticket.summary = up_ticket['summary']
update_ticket.description = up_ticket['description']
update_ticket.type = up_ticket['type']
update_ticket.component = up_ticket['component']
update_ticket.severity = up_ticket['severity']
update_ticket.priority = up_ticket['priority']
update_ticket.owner = up_ticket['owner']
update_ticket.reporter = up_ticket['reporter']
update_ticket.cc = up_ticket['cc']
update_ticket.version = up_ticket['version']
update_ticket.milestone = up_ticket['milestone']
update_ticket.status = up_ticket['status']
update_ticket.resolution = up_ticket['resolution']
update_ticket.keywords = up_ticket['keywords']
update_ticket.product = up_ticket['product']
update_ticket.modified_time = datetime.datetime.now()
# db.session.add(user)
try:
db.session.commit()
logged_user = 1
# Storing data in audit table
logging.info('put ticket start db call')
log_audit("Update Ticket", "Update Ticket", "SAR", None, None,
logged_user, datetime.datetime.now())
logging.info('put ticket start Exiting')
return wrapper.wrapper(None, "Success", 201), 201
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
logging.info('put ticket start Exiting')
db.session.rollback()
return wrapper.wrapper(None, e.message, 500), 500
def get_sar_by_page_count(page, count):
per_page = count
if request.method == 'GET':
logging.info('get users/page/<int:page> start and db call')
get_users = Users.query.filter_by(
user_type='ComplainceTeamMember').paginate(page, per_page, False,
20)
logging.info('get users/page/<int:page> start and db call success')
# print("get_sar----->",get_sar.items)
# print("Type--->", type(get_sar.items))
all_users = []
for sar in get_users.items:
all_users.append(sar.to_dict())
pagination_data = {
'has_next': get_users.has_next,
'pages': get_users.pages,
'has_prev': get_users.has_prev,
'total': get_users.total,
'page': get_users.page,
'next_num': get_users.next_num,
'users': all_users
}
logging.info('get users/page/<int:page> exiting')
return wrapper.wrapper(pagination_data, "Getting all CTM users.", 200)
def forgot_new(token):
reset_data = request.json
logging.info('forget token db call')
user = Users.query.filter_by(password_reset_token=token).first()
logging.info('forget token db call success')
if user is not None:
user.password = bcrypt.generate_password_hash(reset_data['password'])
user.password_reset_token = None
try:
db.session.commit()
logging.info('forget token exiting')
return render_template(
'sar-Response.html',
SAR_response='Password successfully changed.')
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
logging.info('forget token exiting')
db.session.rollback()
return wrapper.wrapper(None, e.message, 500), 500
else:
logging.info('forget token exiting')
return render_template(
'sar-Response.html',
SAR_response='Password change was unsuccessful.')
def logout(user_id):
#sesson = User_Session.query.filter_by(user_id=user_id).first()
#if sesson is not None:
# db.session.delete(sesson)
# db.session.commit()
logging.info('logout entry and exit')
return wrapper.wrapper(None, "Session Successfully deleted", 201), 201
def create_ticket_info():
print("Entering method")
if request.method == 'POST':
logging.info('post ticket info and start')
json_data = request.json
logging.info('post ticket info db call')
tic = TicketInfo.query.all()
logging.info('post ticket info db response')
a = []
for t in tic:
a.append(t.id)
maxuid = max(a)
id = None
if tic:
id = maxuid + 1
else:
id = 1
model_user = TicketInfo(json_data, id)
# model_user = TicketInfo(json_data)
try:
db.session.add(model_user)
db.session.commit()
logged_user = 1
# Storing data in audit table
log_audit("Create Ticket", "Create Ticket", "SAR", logged_user,
datetime.datetime.now(), None, None)
#print("ticket info ---->",)
logging.info('post ticket info Exiting')
return wrapper.wrapper(None, "Success", 201), 201
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
logging.error('post ticket info Exiting')
db.session.rollback()
return wrapper.wrapper(None, e.message, 500), 500
if request.method == 'GET':
logging.info('get ticket info and db call')
get_users = TicketInfo.query.all()
logging.info('get ticket info and db call success')
all_users = []
for user in get_users:
all_users.append(user.to_dict())
logging.info('get ticket info Exiting')
return wrapper.wrapper(all_users, None, 200), 200
def progress_ticket(id):
logging.info('put /ticket/accept and db call')
update_ticket = Ticket.query.filter_by(id=id).first()
logging.info('put /ticket/accept and db call success')
if request.method == 'PUT':
if update_ticket is not None:
up_ticket = request.json
update_ticket.status = up_ticket['status']
update_ticket.modified_time = datetime.datetime.now()
try:
try:
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
logged_user = 1
# Storing data in audit table
log_audit("Accept Ticket", "Accept Ticket", "SAR", logged_user,
datetime.datetime.now(), None, None)
sar = Sar.query.filter_by(id=update_ticket.sar_id).first()
user = Users.query.filter_by(id=sar.user_id).first()
mail_tempate = render_template(
'sar-acceptance.html',
name=user.name,
company=current_app.config['DEFAULT_COMPANY_NAME'],
ticketID=id,
status='Accepted')
sendMail("Ticket successfully assigned.", user.email,
mail_tempate)
# send_email(user.email, "Your SAR accepted.", mail_tempate)
logging.info('put /ticket/accept exiting')
return wrapper.wrapper(None, "Ticket successfully assigned.",
201), 201
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
logging.info('put /ticket/accept exiting')
db.session.rollback()
return wrapper.wrapper(None, e.message, 500), 500
else:
logging.info('put /ticket/accept exiting')
return wrapper.wrapper(None, "Ticket not found.", 201), 201
def create_ticket():
if request.method == 'POST':
logging.info('post ticket method start')
json_data = request.json
logging.info('get ticket call db')
tic = Ticket.query.all()
a = []
for t in tic:
a.append(t.uid)
maxuid = max(a)
logging.info('get ticket db response')
json_data['created_time'] = datetime.datetime.now()
id = None
if tic:
id = maxuid + 1
else:
id = 1
model_user = Ticket(json_data, id, json_data['sar_id'])
try:
db.session.add(model_user)
db.session.commit()
logged_user = 1
# Storing data in audit table
log_audit("Create Ticket", "Create Ticket", "SAR", logged_user,
datetime.datetime.now(), None, None)
data = {'ticket_id': model_user.id}
logging.info('get ticket success exiting')
return wrapper.wrapper(data, "Success", 201), 201
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
logging.error('get ticket success exiting')
db.session.rollback()
return wrapper.wrapper(None, e.message, 500), 500
if request.method == 'GET':
logging.info('get ticket and db method start')
get_users = Ticket.query.all()
logging.info('get ticket and db call success')
all_users = []
for user in get_users:
all_users.append(user.to_dict())
logging.info('get ticket and Exiting')
return wrapper.wrapper(all_users, None, 200), 200
def create_license():
if request.method == 'POST':
json_data = request.json
email = json_data['email']
for_users_left = json_data['no_of_users']
customer_id = str(json_data['customer_id'])
no_of_users = str(json_data['no_of_users'])
no_of_modules = str(json_data['no_of_modules'])
domain = str(json_data['domain'])
license_data = customer_id + "," + no_of_modules + "," + no_of_users + "," + domain
print("data")
keysize = 2048
(public, private) = rsa.newkeys(keysize)
#encrypted = b64encode(rsa.encrypt(license_data, public))
#decrypted = rsa.decrypt(b64decode(encrypted), private)
signature = b64encode(rsa.sign(license_data, private, "SHA-512"))
#verify = rsa.verify(license_data, b64decode(signature), public)
privateKey = private.exportKey('PEM')
publicKey = public.exportKey('PEM')
users_left = for_users_left - 1
expary_date = datetime.datetime.now()
model_data = License(json_data,
expary_date=expary_date,
privateKey=privateKey,
publicKey=publicKey,
signature=signature,
users_left=users_left)
try:
db.session.add(model_data)
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
mail_tempate = render_template('license-Key.html',
licenseKey=publicKey)
send_email(email, "Yor License Key From Complaince!", mail_tempate)
# password_reset__url = url_for('user.confirm_email', token=token, _external=True)
#html = render_template('license-key.html', licenseKey=publicKey,
# name="Some Username", company="Some Company name")
#subject = "Your LicenseKey From Complaince!"
#send_mail.send_email(email, subject, html)
ret = {'res': 'LicenseKey sent to Your Email'}
return wrapper.wrapper(ret, None, 200), 200
if request.method == 'GET':
get_license = License.query.all()
all_lics = []
for license in get_license:
all_lics.append(license.to_dict())
return make_response(jsonify(all_lics)), 200
def get_by_type(user_type):
if request.method == 'GET':
all_users = []
logging.info('get user type call and db call')
user = Users.query.filter_by(user_type=user_type).all()
logging.info('get user type call and db call success')
for u in user:
all_users.append(u.to_dict())
logging.info('get user type call exiting')
return wrapper.wrapper(all_users, "Getting user by type", 200), 200
def update_user_type(user_id):
logging.info('update user type by id db call')
user = Users.query.filter_by(id=user_id).first()
logging.info('update user type by id db call success')
if request.method == 'PUT':
logging.info('update user type by put method')
if user is not None:
update_user = request.get_json()
print("user---type:", update_user['user_type'])
user.user_type = update_user['user_type']
try:
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
logging.info('update user type by put method exiting')
return wrapper.wrapper(None, "success updated user data",
201), 201
else:
logging.info('update user type by put method exiting')
return wrapper.wrapper(None, "User not found", 201), 201
def get_tickets_sarid(sar_id):
logging.info('put tickets/by_sar start and db call')
get_tickets = Ticket.query.filter(Ticket.sar_id == sar_id)
logging.info('put and db call success')
all_ticket = []
for ticket in get_tickets:
# for tic in sar.ticketinfo.all():
# for dep in tic.department.all():
# print("Inside address--->", dep.name)
all_ticket.append(ticket.to_dict())
logging.info('put and exiting')
return wrapper.wrapper(all_ticket, None, 200), 200
def assign_ticket(id):
data = request.json
if request.method == 'PUT':
logging.info('put ticket/assign/ and db call')
ticket = Ticket.query.filter_by(id=id).first()
logging.info('put db success')
ticket.owner = data['owner']
ticket.modified_time = datetime.datetime.now()
#ticket.status='active'
try:
try:
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
user = Users.query.filter_by(name=ticket.owner).first()
now = datetime.datetime.now()
date = now.date()
# Storing data in audit table
log_audit("Assign Ticket", "Assign Ticket", "SAR", user.id,
datetime.datetime.now(), None, None)
mail_tempate = render_template(
'sar-notification.html',
name=user.name,
status=ticket.status,
company=current_app.config['DEFAULT_COMPANY_NAME'],
ticketID=ticket.id,
date=date,
priority=ticket.priority)
sendMail("Ticket Assigned to you", user.email, mail_tempate)
# send_email(user.email, "Ticket Assigned to you", mail_tempate)
logging.info('put ticket/assign/ exit')
return wrapper.wrapper(None, "Ticket assigned successfully",
201), 201
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
logging.info('put ticket/assign/ exit')
return wrapper.wrapper(None, e.message, 500), 500
def forgot(email):
logging.info('forget password db call')
user = Users.query.filter_by(email=email).first()
logging.info('forget password db call success')
if user:
token = uuid.uuid4()
user.password_reset_token = token
try:
try:
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
password_reset__url = url_for('user.forgot_new',
token=token,
_external=True)
html = render_template('change-password1.html',
password_reset__url="http://" +
BaseConfig.BASE_URL + "/forgot/new/" +
str(token),
name=user.name,
company=user.name)
subject = "Password reset"
sendMail(subject, email, html)
# send_mail.send_email(email, subject, html)
print("valid user")
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
logging.info('forget password exiting')
return wrapper.wrapper(None, e.message, 500), 500
logging.info('forget password exiting')
return wrapper.wrapper(None, "Sent email with reset link", 200), 200
else:
logging.info('forget password exiting')
return wrapper.wrapper(None, "Email id not registered with us",
201), 201
def get_all_team_member():
if request.method == 'GET':
logging.info('get all team member start and db call')
get_users = Users.query.filter(
Users.user_type == UserType.COMPLIANCETEAMMEMBER)
logging.info('get all team member start and db call success')
print("all user-->", get_users)
all_users = []
for user in get_users:
for i in user.address.all():
print("pincode-->", i.pincode)
all_users.append(user.to_dict())
logging.info('get all team member start exiting')
return wrapper.wrapper(all_users, None, 200), 200
def auth_user():
logging.info('auth post info start')
json_data = request.json
email = json_data["email"]
user = Ticket.query.filter_by(email=email).first()
g.current_user = user
login_user(user)
if user is not None:
# Identity can be any data that is json serializable
access_token = create_access_token(identity=user.id)
logging.info('auth post info Exit')
return jsonify(access_token=access_token), 200
else:
logging.info('auth post info Exit')
return wrapper.wrapper(None, "user not found", 204), 204
def login():
"""View function for login view."""
logging.info('usre login start')
params = request.get_json()
email = params.get('email', None)
password = params.get('password', None)
client_ip = params.get('client_ip', None)
logging.info('usre login start db call')
user = Users.query.filter_by(email=email).first()
logging.info('usre login start db call success')
if not user:
return wrapper.wrapper(None, "User not found.", 200), 200
if user:
if user.confirmed is True:
logging.info('usre login start validation user call')
compare = bcrypt.check_password_hash(user.password, password)
# TODO Check from DB here
if compare is False:
return wrapper.wrapper(None, "Bad email or password", 201), 201
else:
user_type = user.user_type
user_group = user.user_group
# sesson = User_Session.query.filter_by(user_id=user.id).first()
# if sesson is not None:
# return wrapper.wrapper(None, "Already Loged In To Ip:" + sesson.client_ip, 201), 201
# else:
# model_session = User_Session(client_ip=client_ip, user_id=user.id, user_name=user.name, user_type=user.user_type,
# status='LogedIn')
# db.session.add(model_session)
# db.session.commit()
# user_type = user.user_type
# user_group = user.user_group
ret = {
'jwt': create_jwt(identity=user_group),
'role': user_type,
'user_id': user.id,
'exp':
datetime.utcnow() + current_app.config['JWT_EXPIRES']
}
return wrapper.wrapper(ret, None, 200), 200
else:
logging.info('usre login success')
return wrapper.wrapper(
None, "Email not validated. Please validate and try again.",
200), 200
if not email:
return wrapper.wrapper(None, "Missing email parameter", 201), 201
if not password:
return wrapper.wrapper(None, "Missing password parameter", 201), 201
def getInfoBySarId(sar_id):
if request.method == 'GET':
logging.info('get ticket info method')
all_info = []
logging.info('get ticket info db call')
info = TicketInfo.query.filter_by(sar_id=sar_id).all()
logging.info('get ticket info db success')
for i in info:
#all_info.append(i.to_dict())
json = {
"department": i.__dict__['department'].to_dict(),
"sar": i.__dict__['sar'].to_dict(),
"ticket": i.__dict__['tickets'].to_dict(),
"user": i.__dict__['sar'].__dict__['user'].to_dict()
}
all_info.append(json)
logging.info('get ticket info db Exiting')
return wrapper.wrapper(all_info, "Getting all ticket info by sar id.",
200), 200
def confirm_email(token):
logging.info('confirm token db call')
user = Users.query.filter_by(token=token).first()
logging.info('confirm token db call success')
if user:
user.confirmed = True
user.confirmed_on = datetime.now()
user.token = None
try:
db.session.commit()
print("Get user by token", user.email)
return render_template(
'sar-Response.html',
SAR_response='Email confirmed successfully!')
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
logging.info('confirm token exiting')
db.session.rollback()
return wrapper.wrapper(None, e.message, 500), 500
else:
logging.info('confirm token exiting')
return render_template('sar-Response.html',
SAR_response='User not found!')
def create_user_external_user_test():
json_data = request.json
token = uuid.uuid4()
created_by = json_data["created_by"]
logging.info('create external user carete and db call')
license_data = License.query.filter_by(created_by=created_by).first()
logging.info('create external user carete and db call success')
if license_data is not None:
if license_data.users_left is not 0:
user_count = license_data.users_left - 1
update_license = license_data
license_data.users_left = user_count
try:
db.session.add(update_license)
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
user_type = UserType.EXTERNALUSER
user_group = GroupName.GROUP2
model_user = Users(json_data,
confirmed=False,
token=token,
user_type=user_type,
user_group=user_group)
addr = Address(json_data['address'])
model_user.address.append(addr)
try:
db.session.add(model_user)
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
confirm_url = url_for('user.confirm_email',
token=token,
_external=True)
html = render_template(
'verification-email.html',
confirm_url=confirm_url,
name=json_data['name'],
company=current_app.config['DEFAULT_COMPANY_NAME'],
licenseKey=license_data.publicKey)
subject = "Please confirm your email"
sendMail(subject, json_data['email'], html)
# send_mail.send_email(json_data['email'], subject, html)
logging.info('create external user exiting')
return wrapper.wrapper(
None,
"External user created successfully And Key Sent To The User",
200), 200
else:
logging.info('create external user exiting')
return wrapper.wrapper(None, "Your User Count Exceeded!", 201), 201
else:
logging.info('create external user exiting')
return wrapper.wrapper(None, "You dont have License Yet!", 201), 201
def create_user_administrator():
if request.method == 'POST':
logging.info('create admin post statry')
json_data = request.json
token = uuid.uuid4()
user_type = UserType.ADMINISTRATOR
user_group = GroupName.GROUP1
model_user = Users(json_data['primary'],
confirmed=False,
token=token,
user_type=user_type,
user_group=user_group)
addr = Address(json_data['primary']['address'])
# sar = Sar(json_data['sar'])
# model_user.sar.append(sar)
model_user.address.append(addr)
org_data = json_data['organization']
# Organization data
org = Organization()
org.companyName = org_data['companyName']
org.contactNo = org_data['contactNo']
org.registrationNumber = org_data['registrationNumber']
org.vatNumber = org_data['vatNumber']
org.primary_user = json_data['primary']['email']
org.secondary_user = json_data['secondary']['email']
model_user.organization.append(org)
db.session.add(model_user)
try:
try:
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
# Secondary User
sec_user = Users(json_data['secondary'],
confirmed=False,
token=token,
user_type=user_type,
user_group=user_group)
addr = Address(json_data['secondary']['address'])
# sar = Sar(json_data['sar'])
# model_user.sar.append(sar)
sec_user.address.append(addr)
try:
db.session.add(sec_user)
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
confirm_url = url_for('user.confirm_email',
token=token,
_external=True)
html = render_template(
'verification-email.html',
confirm_url=confirm_url,
name=json_data['primary']['name'],
company=current_app.config['DEFAULT_COMPANY_NAME'])
subject = "Please confirm your email"
sendMail(subject, json_data['primary']['email'], html)
# send_mail.send_email(json_data['email'], subject, html)
moodle_user = {
"auth": "manual",
"confirmed": 1,
"policyagreed": 0,
"deleted": 0,
"suspended": 0,
"mnethostid": 1,
"username": json_data['primary']['email'],
"password": model_user.password,
"firstname": json_data['primary']['name'],
"lastname": 'User',
"email": json_data['primary']['email'],
"emailstop": 0,
"city": json_data['primary']['address']['city'],
"country": json_data['primary']['address']['country'][:2],
"lang": "en",
"calendartype": "gregorian",
"timezone": "99",
"picture": 0,
"descriptionformat": 1,
"mailformat": 1,
"maildigest": 0,
"maildisplay": 1,
"autosubscribe": 0,
"trackforums": 0,
"timecreated": 0,
"trustbitmask": 0
}
logging.info('create external user added db data')
model_data = MdlUser(moodle_user)
try:
db.session.add(model_data)
db.session.commit()
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
db.session.rollback()
logging.info('create admin post exiting')
return wrapper.wrapper(None,
"Administrator user created successfully",
201), 201
except (sqlalchemy.exc.SQLAlchemyError,
sqlalchemy.exc.DBAPIError) as e:
logging.info('create admin post exiting')
return wrapper.wrapper(None, e.message, 500), 500
if request.method == 'GET':
logging.info('create admin get and db call')
get_users = Users.query.all()
logging.info('create admin get and db call success')
all_users = []
for user in get_users:
for i in user.address.all():
print("pincode-->", i.pincode)
all_users.append(user)
logging.info('create admin get and exiting')
return wrapper.wrapper(to_json(all_users), "Getting all users",
200) #(data,msg,status_code)
