def change_user_password(self):
try:
json_data = _get_json_values(
fields_to_check=['login', 'request_type', 'password'])
request_type = json_data.get('request_type', False)
login = json_data.get('login', False)
user = request.env['res.users'].sudo().search([('login', '=',
login)])
if not user.id:
raise UserWarning("User not found: {}:".format(user))
if request_type == 'match':
status = 1
try:
user.with_user(user.id)._check_credentials(
password=json_data.get('password'))
except Exception as e:
_logger.info(
"Exception raise during password match {0}".format(e))
status = 0
return {'status': status}
if request_type == 'update':
update_status = user.write(
{'password': json_data.get('password')})
return {'status': int(update_status)}
except Exception as e:
return {'message': e, 'status_code': '4002'}
def get_google_distance(self, partner_cords=[], company_cords=[]):
if len(partner_cords) == 2 and len(company_cords) == 2:
config_obj = self.env['ir.config_parameter'].sudo()
api_key = config_obj.get_param(
'base_geolocalize.google_map_api_key', '')
api_url = config_obj.get_param('apty_api_app.google_distance_url',
'')
if not all([len(api_url), len(api_key)]):
raise (
"Configuration missing for google distance API key-{0} ---- URL-{1}"
.format(api_key, api_url))
query_string = urlencode({
'key': api_key,
'units': 'metric',
'origins': ','.join(company_cords),
'destinations': ','.join(partner_cords),
})
google_map_url = "{}?{}".format(api_url, query_string)
response = py_request("GET",
url=google_map_url,
data={},
headers={})
if response.status_code:
json_response = json.loads(response.text)
_logger.info(
"Google Distance API response:{0}".format(json_response))
response_distance = []
rows = json_response.get('rows')
for row in rows:
response_distance.append(self._get_rows_distance(row))
return min(response_distance)
def write(self, values):
if values.get('state', False):
if values.get('state') not in ['sale', 'done']:
values.update({'apty_order_state': 'draft'})
res = super(SaleOrder, self).write(values)
if values.get('partner_shipping_id', False):
for record in self:
partner = record.partner_shipping_id.browse(
values.get('partner_shipping_id'))
if not partner.id:
_logger.info("Could not find the partner for the order.")
delivery_price = self.get_shipping_amount(partner_id=partner)
delivery_product = self.env.ref(
'delivery.product_product_delivery_product_template')
delivery_line = self.order_line.filtered(
lambda x: x.product_id.product_tmpl_id.id ==
delivery_product.id)
if not delivery_line.id:
delivery_line.create({
'product_id':
delivery_product.product_variant_ids.id,
'product_uom_qty':
1.0,
'price_unit':
delivery_price,
'order_id':
record.id,
})
else:
delivery_line.write({'price_unit': delivery_price})
return res
def check_zip_code(self):
try:
json_data = _get_json_values(fields_to_check=['pincode'])
pincode = request.env['regional.postal.code'].sudo().search([
('name', '=', json_data.get('pincode'))
])
return {'status': len(pincode) and True or False}
except Exception as e:
_logger.info(
"Exception occurred while checking zip code {0}".format(e))
return {'status': 2000, 'message': e}
def prepare_kitchen_screen(self):
render_view_data, data = {}, {}
try:
data = self.get_sale_orders_data()
render_view_data = {'status': True, 'data': data}
except Exception as e:
render_view_data = {'status': False}
_logger.info(
"Exception occurred while preparing kitchen date: {}".format(
pformat(e)))
return self.env['ir.ui.view'].render_template(
"apty_kitchen_screen.kitchen_screen_template", render_view_data)
def app_payment(self, **kwargs):
try:
json_data = _get_json_values(
fields_to_check=['order_id', 'payment_provider'])
payment_type = json_data.get('payment_provider')
order = request.env['sale.order'].sudo().browse(
int(json_data.get('order_id')))
if not order.id:
raise UserWarning("Order not found")
partner_country_id = order.partner_id.country_id.id
partner_country_ifcd = partner_country_id and partner_country_id or order.company_id.country_id.id
acquirer_id = request.env['payment.acquirer'].sudo().search([
('provider', '=', payment_type)
])
if not acquirer_id.id:
raise UserWarning("Payment Acquirer not found")
payment_tx_id = request.env['payment.transaction']
py_transc = order._create_payment_transaction(
vals={
'acquirer_id': acquirer_id.id,
'partner_country_id': partner_country_id
})
payment_values = {}
if py_transc.id:
if payment_type == 'cash_on_delivery':
order.action_confirm()
order._create_invoices()
py_transc = False
elif payment_type == 'paytm':
payment_values = acquirer_id._prepare_app_values(
order_id=order, transaction=py_transc)
method = getattr(
acquirer_id, '{0}_form_generate_values'.format(
acquirer_id.provider))
payment_values = method(payment_values, CHANNEL_ID='WAP')
payment_tx_id = py_transc
py_transc = py_transc.id
order.write({'payment_acquirer_id': acquirer_id.id})
return {
'status': 2000,
'payment_tx_id': payment_tx_id.id,
'request_values': payment_values,
'payment_tx_id': py_transc,
}
except Exception as e:
_logger.info(
"Exception occurred while initiating app payment - {0}-{1}".
format(e, json_data))
return {'status': 2001, 'result': e}
def mobile_verification(self, **kwargs):
try:
json_data = _get_json_values(
fields_to_check=['mobile', 'request_type'])
if len(json_data):
sms_api_key = request.env['ir.config_parameter'].sudo(
).get_param('apty_api_app.sms_api_key', False)
if not sms_api_key or not len(sms_api_key):
_logger.info(
"SMS API Key is not set, Please set for mobile number verification"
)
raise UserWarning("Something went wrong")
url = "https://2factor.in/API/V1"
if json_data.get('autogen', False):
if not json_data.get('mobile', False):
raise UserWarning("Not enough values for verification")
users = request.env['res.users'].sudo().search([
('login', '=', json_data.get('mobile'))
])
if json_data.get('request_type', '') == 'signup' and len(
users.ids):
raise UserWarning(
"User already exists with this mobile number")
if json_data.get('request_type',
'') == 'password' and not len(users.ids):
raise UserWarning(
"User does not found with this mobile number")
url = '{0}/{1}/SMS/+91{2}/AUTOGEN'.format(
url, sms_api_key, json_data.get('mobile'))
elif json_data.get('verify', False):
if not json_data.get('session_id',
False) and not json_data.get(
'otp', False):
raise UserWarning("Not enough values for verification")
url = '{0}/{1}/SMS/VERIFY/{2}/{3}'.format(
url, sms_api_key, json_data.get('session_id'),
json_data.get('otp'))
response = requests.request("GET", url, headers={}, data={})
return json.loads(response.text)
except Exception as e:
return {'message': "{0}".format(e), 'status_code': "4003"}
def get_unavailable_lines(self):
lines = []
try:
for ol in self.order_line.filtered(
lambda x: x.product_id.id != self.env.ref(
self.env.
ref('delivery.product_product_delivery_product_template'
).id)):
if not (ol.product_id.availability_time_start <
_get_current_time() <
ol.product_id.availability_time_end):
lines.append(ol.id)
except Exception as e:
_logger.info(
"Exception occurred while preparing unavailable lines {}".
format(e))
return lines
def get_address_list(self):
try:
partner_address = []
json_data = _get_json_values(fields_to_check=['user_id'])
partner = request.env['res.users'].sudo().search([
('id', '=', int(json_data.get('user_id')))
])
if partner.id:
partner = partner.partner_id
partner_address.append(partner._get_address_values())
for child in partner.child_ids.filtered(
lambda x: x.type == 'delivery' and x.active == True):
partner_address.append(child._get_address_values())
return partner_address
else:
raise UserWarning("User not found")
except Exception as e:
_logger.info(
"Exception occurred while checking preparing address: {0}".
format(e))
return {'status': 2000, 'message': e}
def prepare_order_lines(self, ol_details=[]):
order_lines = []
if len(ol_details) and self.id:
if not len(self.order_line):
for old in ol_details:
order_lines.append((0, 0, {
'product_id': old.get('product_id'),
'product_uom_qty': old.get('qty'),
}))
else:
for old in ol_details:
product = old.get('product_id')
write_action = 3
ol = self.order_line.filtered(
lambda x: x.product_id.id == product).id
if ol:
write_action = 1
if not ol:
write_action, ol = 0, 0
values = {
'product_id': product,
'product_uom_qty': old.get('qty')
}
order_lines.append((write_action, ol, values))
check_product_ids = map(lambda x: x.get('product_id'),
ol_details)
remove_lines = self.order_line.filtered(
lambda x: x.product_id.id not in check_product_ids)
if len(remove_lines.ids):
_logger.info(
"Removing order lines - {0} with product - {1} for order - {2}"
.format(remove_lines.mapped('id'),
remove_lines.mapped('product_id.name'),
self.name))
order_lines += [(2, rol.id) for rol in remove_lines]
return order_lines
def get_shipping_amount(self, partner_id=False):
try:
if partner_id and partner_id.id:
delivery_charge = self.env['regional.delivery.charge'].search(
[('regional_ids.name', '=', partner_id.zip)], limit=1)
if not delivery_charge:
delivery_charge = self.company_id.order_delivery_charge
else:
delivery_charge = delivery_charge.delivery_charge
return delivery_charge
# partner_id.geo_localize()
# search_cords = self.partner_id.search_read([('id', 'in', [partner_id.id, self.company_id.partner_id.id])],
# ['partner_latitude', 'partner_longitude'],order='id asc')
# partner_cords = [str(search_cords[-1].get(sco)) for sco in ['partner_latitude','partner_longitude']]
# company_cords = [str(search_cords[0].get(sco)) for sco in ['partner_latitude','partner_longitude']]
# geo_distance = self.get_google_distance(partner_cords=partner_cords,company_cords=company_cords)
# geo_distance = geo_distance/1000
# return self.calc_distance_amt(geo_distance=geo_distance) * floor(geo_distance)
except Exception as e:
_logger.info(
"Exception occurred while getting distance {0}".format(e))
return 0
def cod_feedback(self, **post):
_logger.info('Beginning Website COD with post data %s', pprint.pformat(post)) # debug
request.env['payment.transaction'].sudo().form_feedback(post, 'cash_on_delivery')
return werkzeug.utils.redirect('/shop/confirmation')
def app_add_order(self):
try:
json_data = _get_json_values(fields_to_check=['user_id', 'mode'])
_logger.info("Values for App Order: {0}".format(json_data))
values = {}
mode = json_data.get('mode')
ctx = request.env.context.copy()
user = request.env['res.users'].sudo().browse(
int(json_data.get('user_id')))
if not user.id:
return {
'status':
2000,
'message':
'User ID not found in the request {}'.format(json_data)
}
if mode == 'set_shipping_partner':
json_data = _get_json_values(
fields_to_check=['order_id', 'partner_id'])
order = request.env['sale.order'].browse(
int(json_data.get('order_id'))).sudo()
if not order.id:
raise UserWarning("Order not found")
values.update(
{'partner_shipping_id': int(json_data.get('partner_id'))})
order_lines = []
if mode == 'new':
request.session.sale_order_id = False
order = request.website.with_user(user=user).sale_get_order(
force_create=1)
elif mode == 'edit':
order = request.env['sale.order'].browse(
int(json_data.get('order_id'))).sudo()
if not order.id:
raise UserWarning("Order not found")
if len(json_data.get('order_line_details', [])):
order_lines = order.prepare_order_lines(
ol_details=json_data.get('order_line_details', []))
values = {'order_line': order_lines}
if len(json_data.get('delivery_date', '')):
values.update(
{'commitment_date': json_data.get('delivery_date')})
if order and order.partner_id and mode == 'new':
if not order.partner_id.coupon_used:
discount_product = request.env['product.product'].sudo(
).search([('name', 'ilike', 'discount')],
limit=1,
order='id desc')
order_line = {
'product_id': discount_product.id,
'product_uom_qty': 1,
'price_unit': -100,
'price_subtotal': -100
}
order.write({'order_line': [(0, 0, order_line)]})
ctx.update({
'force_company': order.company_id.id,
'allowed_company_ids': [order.company_id.id]
})
request.env.user = user
app_team = request.env.ref('apty_api_app.team_mobile_app')
values['team_id'] = app_team.id
order.sudo().with_context(ctx).write(values)
return {
'order_id': order.id,
}
except Exception as e:
return {'status': 2000, 'message': e}
def app_user_address(self):
try:
json_data = {}
if request.jsonrequest.get('mode',
False) and request.jsonrequest.get(
'mode', '') == 'new':
json_data = _get_json_values(
fields_to_check=['partner_id', 'mode', 'type', 'address'])
if request.jsonrequest.get('mode',
False) and request.jsonrequest.get(
'mode', '') == 'edit':
json_data = _get_json_values(
fields_to_check=['partner_id', 'mode', 'address'])
else:
json_data = _get_json_values(fields_to_check=['partner_id'])
partner = request.env['res.partner'].sudo()
values = json_data.get('address')
status = False
partner_id = partner.browse(int(json_data.get('partner_id')))
if not partner_id.id:
raise UserWarning("Partner not found")
if json_data.get('mode') == 'delete':
order = request.env['sale.order'].search([
('partner_shipping_id', '=', partner_id.id)
])
if not len(order.ids):
status = partner_id.unlink()
else:
partner_id.active = False
status = not partner_id.active
if json_data.get('mode') == 'new':
values.update({
'company_id':
False,
'lang':
request.lang.code,
'country_id':
request.env.ref('base.in').id,
'state_id':
request.env.ref('base.state_in_tn').id,
})
if json_data.get('type') == 'shipping':
values.update({
'parent_id':
partner_id.commercial_partner_id.id,
'type':
'delivery',
})
ctx = request.env.context.copy()
company_id = partner_id.company_id.id and partner_id.company_id.id or request.website.company_id.id
ctx.update({
'mail_create_nosubscribe': True,
'force_company': company_id,
})
partner_id = partner.with_context(ctx).create(values).id
status = bool(partner_id)
elif json_data.get('mode') == 'edit':
status = partner_id.write(values)
if json_data.get('order_id', False):
order = request.env['sale.order'].sudo().browse(
int(json_data.get('order_id')))
order.partner_shipping_id = partner_id.id
return {'status': status}
except Exception as e:
_logger.info(
"Exception occurred while user address action: {0} - {1}".
format(e, pprint(json_data)))
return {'status': False, 'message': e}
def website_registration_complete(self, **kwargs):
valid = False
sale_order_lines = request.env["sale.order.line"]
sale_order = request.env["sale.order"]
res = {}
so_id = request.params.get("id")
token = request.params.get("token")
if so_id:
sale_order = (request.env["sale.order"].sudo().search([
("id", "=", int(so_id)),
("state", "in", ["sale", "done", "in_progress"]),
]))
if (sale_order and token and sale_order.event_token == token
and sale_order.event_token_valid):
valid = True
# Get attendee records that are not related to a learning product
all_attendee_ids = sale_order.attendee_ids
attendee_ids = all_attendee_ids.filtered(
lambda a: not a.sale_order_line_id.product_id.
product_tmpl_id.is_learning_product)
# attendee_events = attendee_ids.mapped("event_id")
_logger.info("Available Events:{} - {}".format(
all_attendee_ids.ids, all_attendee_ids.mapped('event_id')))
for event in sale_order.order_line.mapped(
'product_id.event_template_id'):
res[event.id] = {"event_obj": event, "tickets": {}}
tickets = attendee_ids.mapped("event_ticket_id").filtered(
lambda r: r.event_id.id == event.id)
for ticket in tickets:
res[event.id]["tickets"][ticket.id] = {
"ticket_obj": ticket,
"attendees": event.registration_ids,
}
_logger.info("Processed Available Events:{} - {}".format(
all_attendee_ids.ids, res))
# learning_order_line_ids = sale_order.order_line.filtered(
# lambda l: l.product_id.product_tmpl_id.is_learning_product
# )
# for l in learning_order_line_ids:
# res["learning-so-line-id--" + str(l.id)] = {
# "event_obj": l.product_id.event_template_id,
# "tickets": {
# l.product_id.ticket_id.id: {
# "ticket_obj": l.product_id.ticket_id,
# "attendees": all_attendee_ids.filtered(
# lambda a: a.is_a_template
# and a.sale_order_line_id.id == l.id
# ),
# }
# },
# }
return request.render(
"website_event_late_reg.complete_registration",
{
"valid": valid,
"res": res,
"sale_order": sale_order
},
)