def create_group_in_hunterscamp(request_data):
if request_data:
request_data = json.loads(request_data)
putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["operation", "property_type", "property_subtype"])
putil.init_for_location_or_city_creation(request_data)
request_data["property_subtype_option"] = ','.join(request_data.get("property_subtype_option")) if request_data.get("property_subtype_option") else " "
group_search_conditions = make_conditions_for_duplicate_group(request_data, "Group")
group_result = frappe.db.sql(""" select name from `tabGroup` {0} """.format(group_search_conditions),as_dict=True)
if group_result:
group_result = [ group.get("name") for group in group_result if group ]
raise DuplicateEntryError("Group {0} with same configuration already exists".format(','.join(group_result)))
try:
gr_doc = frappe.new_doc("Group")
gr_doc.group_title = request_data.get("group_title")
gr_doc.operation = request_data.get("operation")
gr_doc.property_type = request_data.get("property_type")
gr_doc.property_subtype = request_data.get("property_subtype")
gr_doc.location = request_data.get("location")
gr_doc.property_subtype_option = request_data.get("property_subtype_option")
gr_doc.creation_via = "Website"
gr_doc.min_area = request_data.get("min_area")
gr_doc.max_area = request_data.get("max_area")
gr_doc.min_budget = request_data.get("min_budget")
gr_doc.max_budget = request_data.get("max_budget")
gr_doc.unit_of_area = request_data.get("unit_of_area")
gr_doc.city =request_data.get("city")
gr_doc.status = "Active"
gr_doc.save()
return {"operation":"Create", "group_id":gr_doc.name, "message":"Group Created"}
except frappe.MandatoryError,e:
raise MandatoryError("Mandatory Field {0} missing".format(e.message))
except (frappe.LinkValidationError, frappe.ValidationError) as e:
raise InvalidDataError(e.message)
def get_user_profile(data):
request_data = json.loads(data)
putil.validate_for_user_id_exists(request_data.get("user_id"))
try:
user_data = frappe.db.sql(""" SELECT
ifnull(first_name, "") AS first_name,
ifnull(last_name, "") AS last_name,
ifnull(user_image,"") AS user_image,
ifnull(user_id,"") AS user_id,
ifnull(email, "") AS email,
ifnull(mobile_no, "") AS mobile_no,
ifnull(state, "") AS state,
ifnull(city,"") AS city,
ifnull(address, "") AS address,
ifnull(area, "") AS area,
ifnull(pincode, "") AS pincode,
ifnull(birth_date, "") AS birth_date,
ifnull(lattitude,"") AS geo_location_lat,
ifnull(longitude,"") AS geo_location_lon
FROM `tabUser`
WHERE user_id = '{0}' """.format(request_data.get("user_id")),as_dict=True)
user_data = user_data[0]
if user_data.get("user_image"):
user_data["user_image"] = frappe.request.host_url + user_data.get("user_image")
user_data["city"] = frappe.db.get_value("City",user_data["city"],"city_name") or ""
user_data["location"] = frappe.db.get_value("Area",user_data["area"],"area") or ""
return {"operation":"Search", "message":"Profile Found", "data":user_data, "user_id":request_data.get("user_id")}
except Exception,e:
raise GetUserProfileOperationFailed("User Profile Operation failed")
def create_alerts(request_data):
request_data = json.loads(request_data)
putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["operation", "property_type", "property_subtype"])
putil.init_for_location_or_city_creation(request_data)
request_data["property_subtype_option"] = ','.join(request_data.get("property_subtype_option")) if request_data.get("property_subtype_option") else " "
alert_search_conditions = make_conditions_for_duplicate_group(request_data, "Alerts")
alert_result = frappe.db.sql(""" select name from `tabAlerts` {0} """.format(alert_search_conditions),as_dict=True)
if alert_result:
alert_result = [ alert.get("name") for alert in alert_result if alert ]
raise DuplicateEntryError("Alert {0} with same configuration already exists".format(','.join(alert_result)))
try:
alrt = frappe.new_doc("Alerts")
alrt.alert_title = request_data.get("alert_title")
alrt.operation = request_data.get("operation")
alrt.property_type = request_data.get("property_type")
alrt.property_subtype = request_data.get("property_subtype")
alrt.location = request_data.get("location")
alrt.property_subtype_option = request_data.get("property_subtype_option")
alrt.creation_via = "Website"
alrt.min_area = request_data.get("min_area")
alrt.max_area = request_data.get("max_area")
alrt.min_budget = request_data.get("min_budget")
alrt.max_budget = request_data.get("max_budget")
alrt.unit_of_area = request_data.get("unit_of_area")
alrt.user_id = request_data.get("user_id")
alrt.city = request_data.get("city")
alrt.status = "Active"
alrt.save()
return {"operation":"Create", "alert_id":alrt.name, "message":"Alert Created"}
except frappe.MandatoryError,e:
raise MandatoryError("Mandatory Field {0} missing".format(e.message))
def create_group_in_hunterscamp(request_data):
if request_data:
request_data = json.loads(request_data)
putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(
request_data, ["operation", "property_type", "property_subtype"])
putil.init_for_location_or_city_creation(request_data)
request_data["property_subtype_option"] = ','.join(
request_data.get("property_subtype_option")) if request_data.get(
"property_subtype_option") else " "
group_search_conditions = make_conditions_for_duplicate_group(
request_data, "Group")
group_result = frappe.db.sql(
""" select name from `tabGroup` {0} """.format(
group_search_conditions),
as_dict=True)
if group_result:
group_result = [
group.get("name") for group in group_result if group
]
raise DuplicateEntryError(
"Group {0} with same configuration already exists".format(
','.join(group_result)))
try:
gr_doc = frappe.new_doc("Group")
gr_doc.group_title = request_data.get("group_title")
gr_doc.operation = request_data.get("operation")
gr_doc.property_type = request_data.get("property_type")
gr_doc.property_subtype = request_data.get("property_subtype")
gr_doc.location = request_data.get("location")
gr_doc.property_subtype_option = request_data.get(
"property_subtype_option")
gr_doc.creation_via = "Website"
gr_doc.min_area = request_data.get("min_area")
gr_doc.max_area = request_data.get("max_area")
gr_doc.min_budget = request_data.get("min_budget")
gr_doc.max_budget = request_data.get("max_budget")
gr_doc.unit_of_area = request_data.get("unit_of_area")
gr_doc.city = request_data.get("city")
gr_doc.status = "Active"
gr_doc.save()
return {
"operation": "Create",
"group_id": gr_doc.name,
"message": "Group Created"
}
except frappe.MandatoryError, e:
raise MandatoryError("Mandatory Field {0} missing".format(
e.message))
except (frappe.LinkValidationError, frappe.ValidationError) as e:
raise InvalidDataError(e.message)
def get_location_details_for_map(request_data):
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["request_id"])
try:
es = ElasticSearchController()
response = es.search_document_for_given_id("request",request_data.get("request_id"),[],
["search_query", "unit_of_area", "adv_search_query"])
search_query = ast.literal_eval(response.get("adv_search_query").encode("utf8"))
uom = response.get("unit_of_area")
include_fields = ["property_title", "property_id", "location", "property_subtype_option",
"operation", "carpet_area", "price", "geo_location_lat", "geo_location_lon" ]
size = get_count_of_property_records(es)
response_data, total_records = es.search_document(["property"], search_query, 1, size, [], include_fields)
uom = "Sq.Ft." if uom not in ["Sq.Ft.", "Acres", "Hectares"] else uom
putil.convert_area_according_to_uom(response_data, uom)
response_msg = "User Property Found" if response_data else "User property not found"
return {
"operation":"Search",
"user_id":request_data.get("user_id"),
"message":response_msg,
"data":response_data
}
except elasticsearch.TransportError:
raise DoesNotExistError("Request Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
def get_similar_properties(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["request_type", "id"])
search_dict = {"property_id":get_search_query_of_property_id ,"request_id":get_search_query_of_request_id}
if request_data.get("request_type") not in ["property_id", "request_id"]:
raise InvalidDataError("Request type contains Invalid Data")
search_query, uom = search_dict.get(request_data.get("request_type"))(request_data)
try:
sp_include_fields = ["property_photo", "property_id", "location", "address",
"city", "carpet_area", "price","property_title"]
es = ElasticSearchController()
response_data, total_records = es.search_document(["property"], search_query, request_data.get("page_number",1), request_data.get("records_per_page",4), [], sp_include_fields)
uom = "Sq.Ft." if uom not in ["Sq.Ft.", "Acres", "Hectares"] else uom
putil.convert_area_according_to_uom(response_data, uom)
response_msg = "Similar Property Found" if response_data else "Similar property not found"
return {
"operation":"Search",
"message":response_msg ,
"total_records":len(response_data),
"data":response_data,
"user_id":request_data.get("user_id")
}
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Get Similar property Operation Failed")
def share_property(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
user_name = frappe.db.get_value("User", {"user_id":request_data.get("user_id")}, ["first_name", "last_name"],as_dict=True)
putil.validate_property_data(request_data, ["comments", "email_id"])
try:
property_ids_list = { comment.get("property_id"):comment.get("comment","") for comment in request_data.get("comments") if comment.get("property_id")}
search_query = { "query":{ "ids":{ "values":property_ids_list.keys() } }}
es = ElasticSearchController()
response_data, total_records = es.search_document(["property"], search_query, request_data.get("page_number",1), request_data.get("records_per_page",40))
if response_data:
for response in response_data:
response["comments"] = property_ids_list.get(response.get("property_id"),"")
args = { "title":"Property Shared by {0}".format(email) , "property_data":response_data ,"first_name":user_name.get("first_name"), "last_name":user_name.get("last_name")}
send_email(request_data.get("email_id"), "Propshikari properties shared with you", "/templates/share_property_template.html", args)
return { "operation":"Share", "message":"Property Shared"}
else:
raise DoesNotExistError("Property Id does not exists in elastic search")
except frappe.OutgoingEmailError:
raise OutgoingEmailError("Email can not be sent,Outgoing email error")
except elasticsearch.TransportError:
raise DoesNotExistError("Property Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Share Property Operation Failed")
def get_user_properties(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
search_query = { "query": { "match":{ "posted_by":request_data.get("user_id") } } }
try:
# fields_to_be_excluded from response and resultset generation
include_list = ["property_photo", "city", "location", "carpet_area", "amenities", "no_of_floors", "price", "status",
"floor_no", "price_per_sq_ft", "property_id", "property_title", "tag", "possession_status", "property_subtype_option"]
es = ElasticSearchController()
response_data, total_records = es.search_document(["property"], search_query, request_data.get("page_number",1), request_data.get("records_per_page",40), [], include_list)
response_data = check_for_shortlisted_property(response_data, request_data.get("user_id"))
putil.show_amenities_with_yes_status(response_data)
# response data & pagination logic
msg = "User Property Found" if len(response_data) else "User Property not found"
return putil.init_pagination_and_response_generatrion(request_data, response_data, msg, total_records)
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Get User Properties Operation Failed")
def get_shortlisted_property(request_data):
if request_data:
request_data = json.loads(request_data)
# Check if shortlisted property existed against user
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
property_ids_list = frappe.db.get_values("Shortlisted Property", {"user_id":request_data.get("user_id"), "status":"Active"}, "property_id")
if not property_ids_list:
return {"operation":"Search", "message":"No Single Shortlisted property found", "user_id":request_data.get("user_id")}
property_ids_list = [ property_id[0] for property_id in property_ids_list if property_id]
try:
# generate search_query and resultset & fields to be included in response
sp_include_fields= ["property_photo", "city", "location", "carpet_area", "amenities", "no_of_floors",
"price", "status","floor_no", "price_per_sq_ft", "property_id", "property_title",
"tag", "possession_status", "property_subtype_option", "unit_of_area", "property_age"]
search_query = { "query":{ "ids":{ "values":property_ids_list } } }
es = ElasticSearchController()
response_data, total_records = es.search_document(["property"], search_query, request_data.get("page_number",1),
request_data.get("records_per_page",40), [], sp_include_fields)
# response data & pagination logic
append_shortlisted_tag(response_data)
msg = "Shortlisted Property Found" if len(response_data) else "Shortlsited Property not found"
return putil.init_pagination_and_response_generatrion(request_data, response_data, msg, total_records)
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Get Shortlisted Property Operation Failed")
def shortlist_property(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
if not request_data.get("property_id"):
raise MandatoryError("Mandatory Field Property Id missing")
property_name = frappe.db.get_value("Shortlisted Property", {"property_id":request_data.get("property_id"), "user_id":request_data.get("user_id")} ,["name","status"], as_dict=1)
if property_name:
if property_name.get("status") == 'Active':
raise DuplicateEntryError("Property {0} already Shortlisted".format(request_data.get("property_id")))
elif property_name.get("status") == 'Inactive':
sp_doc = frappe.get_doc("Shortlisted Property", property_name.get("name"))
sp_doc.status = "Active"
sp_doc.save(ignore_permissions=True)
else:
try:
sp_doc = frappe.new_doc("Shortlisted Property")
sp_doc.user_id = request_data.get("user_id")
sp_doc.property_id = request_data.get("property_id")
sp_doc.status = "Active"
sp_doc.save()
es = ElasticSearchController()
es.refresh_index()
except frappe.MandatoryError,e:
raise MandatoryError("Mandatory Field {0} missing".format(e.message))
except (frappe.LinkValidationError, frappe.ValidationError) as e:
raise InvalidDataError(e.message)
except Exception,e:
raise OperationFailed("Shortlist Property Operation Failed")
def get_location_details_for_map(request_data):
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["request_id"])
try:
es = ElasticSearchController()
response = es.search_document_for_given_id("request",request_data.get("request_id"),[],
["search_query", "unit_of_area", "adv_search_query"])
search_query = ast.literal_eval(response.get("adv_search_query").encode("utf8"))
uom = response.get("unit_of_area")
include_fields = ["property_title", "property_id", "location", "property_subtype_option",
"operation", "carpet_area", "price", "geo_location_lat", "geo_location_lon" ]
size = get_count_of_property_records(es)
response_data, total_records = es.search_document(["property"], search_query, 1, size, [], include_fields)
uom = "Sq.Ft." if uom not in ["Sq.Ft.", "Acres", "Hectares"] else uom
putil.convert_area_according_to_uom(response_data, uom)
response_msg = "User Property Found" if response_data else "User property not found"
return {
"operation":"Search",
"user_id":request_data.get("user_id"),
"message":response_msg,
"data":response_data
}
except elasticsearch.TransportError:
raise DoesNotExistError("Request Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
def get_user_properties(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
search_query = { "query": { "match":{ "posted_by":request_data.get("user_id") } } }
try:
# fields_to_be_excluded from response and resultset generation
include_list = ["property_photo", "city", "location", "carpet_area", "amenities", "no_of_floors", "price", "status",
"floor_no", "price_per_sq_ft", "property_id", "property_title", "tag", "possession_status", "property_subtype_option"]
es = ElasticSearchController()
response_data, total_records = es.search_document(["property"], search_query, request_data.get("page_number",1), request_data.get("records_per_page",40), [], include_list)
response_data = check_for_shortlisted_property(response_data, request_data.get("user_id"))
putil.show_amenities_with_yes_status(response_data)
# response data & pagination logic
msg = "User Property Found" if len(response_data) else "User Property not found"
return putil.init_pagination_and_response_generatrion(request_data, response_data, msg, total_records)
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Get User Properties Operation Failed")
def get_mascot_status_for_user(data):
request_data = json.loads(data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
validate_mascot_source(request_data)
fields = {
"website":
"shortlist_status, alert_status",
"mobile":
"mobile_alert_status as alert_status, mobile_shortlist_status as shortlist_status"
}
try:
mascot_data = frappe.db.sql("""
select {fields}
from `tabMascot Status`
where user_id = '{uid}'
""".format(fields=fields.get(request_data.get("mascot_source")),
uid=request_data.get("user_id")),
as_dict=True)
return {
"user_id": request_data.get("user_id"),
"message": "Mascot Status Found"
if mascot_data else "Mascot status not found",
"data": mascot_data[0] if mascot_data else ""
}
except Exception, e:
pass
def update_password(data):
user_data = json.loads(data)
putil.validate_property_data(user_data, ["old_password", "new_password"])
user_email = putil.validate_for_user_id_exists(user_data.get("user_id"))
check_password = frappe.db.sql(
"""select `user` from __Auth where `user`=%s
and `password`=password(%s)""", (user_email, user_data.get("old_password")))
if not check_password:
raise InvalidPasswordError("Invalid Old Password")
else:
try:
new_password = user_data.get("new_password")
_update_password(user_email, new_password)
user_info = frappe.db.get("User", {"email": user_email})
args = {
"first_name": user_info.get("first_name"),
"new_password": new_password,
"last_name": user_info.get("last_name")
}
send_email(user_email, "Password Update Notification",
"/templates/password_update.html", args)
return {
"operation": "Password Update",
"message": "Password updated successfully",
"user_id": user_data.get("user_id")
}
except frappe.OutgoingEmailError:
raise OutgoingEmailError(
"Password Updated successfully but email not sent.")
except Exception, e:
raise ForgotPasswordOperationFailed(
"Update password operation failed")
def join_user_with_group_id(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["user_id", "group_id"])
if not frappe.db.get_value(
"Group", {"name": request_data.get("group_id")}, "name"):
raise DoesNotExistError("Group ID {0} does not exists".format(
request_data.get("group_id")))
if frappe.db.get_value(
"Group User", {
"group_id": request_data.get("group_id"),
"user_id": request_data.get("user_id")
}, "name"):
raise DuplicateEntryError("Group {0} already joined".format(
request_data.get("group_id")))
try:
grusr = frappe.new_doc("Group User")
grusr.user_id = request_data.get("user_id")
grusr.group_id = request_data.get("group_id")
grusr.user = email
grusr.save()
return {"operation": "Search", "message": "Group joined"}
except frappe.MandatoryError, e:
raise MandatoryError("Mandatory Field {0} missing".format(
e.message))
except (frappe.LinkValidationError, frappe.ValidationError) as e:
raise InvalidDataError(e.message)
def get_property_contact(request_data):
"""
Get Contact person name, contact_no form property &
generate lead & enquiry against that user.
"""
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
if not request_data.get("property_id"):
raise MandatoryError("Mandatory Field Property Id missing")
try:
es = ElasticSearchController()
response = es.search_document_for_given_id("property",request_data.get("property_id"),[],[])
new_response = { "contact_no": response.get("contact_no"), "contact_person":response.get("contact_person")}
create_lead_from_userid(request_data, email, response)
return {
"operation":"Search",
"message":"Contact Details found" if len(new_response) else "Contact Details Not Found",
"user_id":request_data.get("user_id"),
"data":new_response
}
except elasticsearch.TransportError:
raise DoesNotExistError("Property Id does not exists")
except Exception,e:
raise e
def get_similar_properties(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["request_type", "id"])
search_dict = {"property_id":get_search_query_of_property_id ,"request_id":get_search_query_of_request_id}
if request_data.get("request_type") not in ["property_id", "request_id"]:
raise InvalidDataError("Request type contains Invalid Data")
search_query, uom = search_dict.get(request_data.get("request_type"))(request_data)
try:
sp_include_fields = ["property_photo", "property_id", "location", "address",
"city", "carpet_area", "price","property_title"]
es = ElasticSearchController()
response_data, total_records = es.search_document(["property"], search_query, request_data.get("page_number",1), request_data.get("records_per_page",4), [], sp_include_fields)
uom = "Sq.Ft." if uom not in ["Sq.Ft.", "Acres", "Hectares"] else uom
putil.convert_area_according_to_uom(response_data, uom)
response_msg = "Similar Property Found" if response_data else "Similar property not found"
return {
"operation":"Search",
"message":response_msg ,
"total_records":len(response_data),
"data":response_data,
"user_id":request_data.get("user_id")
}
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Get Similar property Operation Failed")
def remove_tag_of_property(data):
request_data = json.loads(data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
user_data = frappe.db.get_value("User", {"email": user_email},
"user_type",
as_dict=True)
if user_data.get("user_type") == "System User":
try:
es = ElasticSearchController()
response = es.search_document_for_given_id(
"property", request_data.get("property_id"), [], [])
get_modified_datetime(response, user_email)
update_query = get_update_tag_query(request_data,
request_data.get('tags')[0],
response)
es = ElasticSearchController()
update_response = es.update_docuemnt(
"property", request_data.get("property_id"), update_query)
es = ElasticSearchController()
es.refresh_index()
return {
"operation": "update",
"user_id": request_data.get("user_id"),
"message": "Property Tags Updated Successfully"
}
except elasticsearch.TransportError:
raise DoesNotExistError("Property Id does not exists")
except elasticsearch.ElasticsearchException, e:
raise ElasticSearchException(e.error)
def get_property_of_given_id(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
try:
exclude_list = [
"agent_name", "agent_no", "created_by", "modified_by",
"creation_date", "modified_date", "posted_datetime",
"modified_datetime"
]
es = ElasticSearchController()
response = es.search_document_for_given_id(
"property", request_data.get("property_id"), exclude_list)
return {
"operation": "Search",
"message":
"Property found" if len(response) else "Property Not Found",
"user_id": request_data.get("user_id"),
"data": response
}
except elasticsearch.TransportError:
raise DoesNotExistError("Property Id does not exists")
except Exception, e:
raise GetPropertyOperationFailed("Get Property Operation Failed")
def update_project(request_data):
user_email = putil.validate_for_user_id_exists(
request_data.get("fields").get("user_id"))
try:
field_dict = putil.validate_property_posting_data(
request_data.get("fields"),
"property_json/project_post_mapper.json")
get_modified_datetime(field_dict, user_email)
es = ElasticSearchController()
update_project_photos(field_dict, request_data.get("fields"),
request_data.get("project_id"), es)
field_dict["possession_status"] = "Immediate" if field_dict.get(
"possession") else field_dict.get("possession_date")
search_query = {"doc": field_dict}
update_response = es.update_docuemnt("project",
request_data.get("project_id"),
search_query)
percent_script = get_percent_completion_script(
project_mandatory_fields)
per_response = es.update_docuemnt("project",
request_data.get("project_id"),
percent_script)
return {"opeartion": "Update", "message": "Project details Updated"}
except elasticsearch.TransportError:
raise DoesNotExistError("Project Id does not exists")
except elasticsearch.ElasticsearchException, e:
raise ElasticSearchException(e.error)
def get_builder_projects(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
search_query = {
"query": {
"match": {
"posted_by": request_data.get("user_id")
}
}
}
try:
es = ElasticSearchController()
size = get_count_of_project_records(es)
response_data, total_records = es.search_document(
["project"], search_query, request_data.get("page_number",
1), size)
# response data & pagination logic
msg = "User Project Found" if len(
response_data) else "User Project not found"
return putil.init_pagination_and_response_generatrion(
request_data, response_data, msg, total_records)
except elasticsearch.ElasticsearchException, e:
raise ElasticSearchException(e.error)
except Exception, e:
raise OperationFailed("Get Builder Properties Operation Failed")
def update_mascot_status(data):
request_data = json.loads(data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
validate_mascot_source(request_data)
mascot_dict = validate_mascot_data(request_data.get("mascot_list"))
mobile_dict = {
"mobile_shortlist_status": "shortlist_status",
"mobile_alert_status": "alert_status"
}
fields = {
"website": mascot_dict,
"mobile": {
mobile_field: mascot_dict.get(mascot_field)
for mobile_field, mascot_field in mobile_dict.items()
if mascot_dict.has_key(mascot_field)
}
}
try:
ms = frappe.get_doc("Mascot Status",
{"user_id": request_data.get("user_id")})
ms.update(fields.get(request_data.get("mascot_source")))
ms.save(ignore_permissions=True)
return {
"user_id": request_data.get("user_id"),
"message": "Mascot Status Updated Successfully"
}
except Exception, e:
return {
"user_id":
request_data.get("user_id"),
"message":
"Mascot status not found against user {0}".format(user_email)
}
def share_property(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
user_name = frappe.db.get_value("User", {"user_id":request_data.get("user_id")}, ["first_name", "last_name"],as_dict=True)
putil.validate_property_data(request_data, ["comments", "email_id"])
try:
property_ids_list = { comment.get("property_id"):comment.get("comment","") for comment in request_data.get("comments") if comment.get("property_id")}
search_query = { "query":{ "ids":{ "values":property_ids_list.keys() } }}
es = ElasticSearchController()
response_data, total_records = es.search_document(["property"], search_query, request_data.get("page_number",1), request_data.get("records_per_page",40))
if response_data:
for response in response_data:
response["comments"] = property_ids_list.get(response.get("property_id"),"")
args = { "title":"Property Shared by {0}".format(email) , "property_data":response_data ,"first_name":user_name.get("first_name"), "last_name":user_name.get("last_name")}
send_email(request_data.get("email_id"), "Propshikari properties shared with you", "/templates/share_property_template.html", args)
return { "operation":"Share", "message":"Property Shared"}
else:
raise DoesNotExistError("Property Id does not exists in elastic search")
except frappe.OutgoingEmailError:
raise OutgoingEmailError("Email can not be sent,Outgoing email error")
except elasticsearch.TransportError:
raise DoesNotExistError("Property Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Share Property Operation Failed")
def post_project(data):
try:
request_data = json.loads(data) if isinstance(data, unicode) else data
user_email = putil.validate_for_user_id_exists(
request_data.get("user_id"))
user_data = frappe.db.get_value("User", {"email": user_email},
"user_type",
as_dict=True)
if user_data.get("user_type") == "System User":
project_data = putil.validate_property_posting_data(
request_data, "property_json/project_post_mapper.json")
property_details = putil.validate_project_posting_data(
project_data.get("property_details"),
"property_json/project_child_table.json")
project_data["property_details"] = property_details
project_id = init_for_project_posting(project_data, user_email,
request_data.get("user_id"))
init_for_project_photo_upload(request_data, project_data)
response_dict = {
"operation": "Create",
"user_id": request_data.get("user_id")
}
es = ElasticSearchController()
response_data = es.index_document("project", project_data,
project_data["project_id"])
try:
init_for_property_posting(project_data)
response_dict["message"] = "Project Posted Successfully"
except Exception, e:
response_dict[
"message"] = "Project Posted Successfully but Property Posting Failed"
response_dict["project_id"] = project_id
return response_dict
else:
def get_shortlisted_property(request_data):
if request_data:
request_data = json.loads(request_data)
# Check if shortlisted property existed against user
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
property_ids_list = frappe.db.get_values("Shortlisted Property", {"user_id":request_data.get("user_id"), "status":"Active"}, "property_id")
if not property_ids_list:
return {"operation":"Search", "message":"No Single Shortlisted property found", "user_id":request_data.get("user_id")}
property_ids_list = [ property_id[0] for property_id in property_ids_list if property_id]
try:
# generate search_query and resultset & fields to be included in response
sp_include_fields= ["property_photo", "city", "location", "carpet_area", "amenities", "no_of_floors",
"price", "status","floor_no", "price_per_sq_ft", "property_id", "property_title",
"tag", "possession_status", "property_subtype_option", "unit_of_area", "property_age"]
search_query = { "query":{ "ids":{ "values":property_ids_list } } }
es = ElasticSearchController()
response_data, total_records = es.search_document(["property"], search_query, request_data.get("page_number",1),
request_data.get("records_per_page",40), [], sp_include_fields)
# response data & pagination logic
append_shortlisted_tag(response_data)
msg = "Shortlisted Property Found" if len(response_data) else "Shortlsited Property not found"
return putil.init_pagination_and_response_generatrion(request_data, response_data, msg, total_records)
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Get Shortlisted Property Operation Failed")
def validate_for_session_exists(request_data):
request_data = json.loads(request_data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
sessions_status = frappe.db.get_value("Sessions", {"user":user_email, "sid":request_data.get("sid")}, "status")
if sessions_status == "Active":
return { "operation":"search", "session_expired":False, "message":"Session exists against user {0}".format(user_email)}
else:
return { "operation":"search", "session_expired":True, "message":"Session does not exists"}
def create_alerts(request_data):
request_data = json.loads(request_data)
putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(
request_data, ["operation", "property_type", "property_subtype"])
putil.init_for_location_or_city_creation(request_data)
request_data["property_subtype_option"] = ','.join(
request_data.get("property_subtype_option")) if request_data.get(
"property_subtype_option") else " "
alert_search_conditions = make_conditions_for_duplicate_group(
request_data, "Alerts")
alert_result = frappe.db.sql(
""" select name from `tabAlerts` {0} """.format(
alert_search_conditions),
as_dict=True)
if alert_result:
alert_result = [alert.get("name") for alert in alert_result if alert]
raise DuplicateEntryError(
"Alert {0} with same configuration already exists".format(
','.join(alert_result)))
try:
alrt = frappe.new_doc("Alerts")
alrt.alert_title = request_data.get("alert_title")
alrt.operation = request_data.get("operation")
alrt.property_type = request_data.get("property_type")
alrt.property_subtype = request_data.get("property_subtype")
alrt.location = request_data.get("location")
alrt.property_subtype_option = request_data.get(
"property_subtype_option")
alrt.creation_via = "Website"
alrt.min_area = request_data.get("min_area")
alrt.max_area = request_data.get("max_area")
alrt.min_budget = request_data.get("min_budget")
alrt.max_budget = request_data.get("max_budget")
alrt.unit_of_area = request_data.get("unit_of_area")
alrt.user_id = request_data.get("user_id")
alrt.city = request_data.get("city")
alrt.status = "Active"
alrt.save()
return {
"operation": "Create",
"alert_id": alrt.name,
"message": "Alert Created"
}
except frappe.MandatoryError, e:
raise MandatoryError("Mandatory Field {0} missing".format(e.message))
def log_out_from_propshikari(data):
request_data = json.loads(data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
try:
frappe.local.login_manager.logout()
frappe.db.commit()
return {"operation":"Log Out", "message":"Successfully Logged Out"}
except Exception:
raise LogOutOperationFailed("Log Out Unsuccessful")
def log_out_from_propshikari(data):
request_data = json.loads(data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
try:
frappe.local.login_manager.logout()
frappe.db.commit()
return {"operation":"Log Out", "message":"Successfully Logged Out"}
except Exception:
raise LogOutOperationFailed("Log Out Unsuccessful")
def get_user_profile(data):
request_data = json.loads(data)
putil.validate_for_user_id_exists(request_data.get("user_id"))
try:
user_data = frappe.db.sql(""" SELECT
ifnull(first_name, "") AS first_name,
ifnull(last_name, "") AS last_name,
ifnull(user_image,"") AS profile_photo,
ifnull(user_id,"") AS user_id,
ifnull(email, "") AS email,
ifnull(mobile_no, "") AS mobile_number,
ifnull(state, "") AS state,
ifnull(city,"") AS city,
ifnull(address, "") AS address,
ifnull(area, "") AS area,
ifnull(pincode, "") AS pincode,
ifnull(birth_date, "") AS dob,
ifnull(lattitude,"") AS geo_location_lat,
ifnull(longitude,"") AS geo_location_lon
FROM `tabUser`
WHERE user_id = '{0}' """.format(request_data.get("user_id")),
as_dict=True)
user_data = user_data[0]
if user_data.get("profile_photo"):
user_data[
"profile_photo"] = frappe.request.host_url + user_data.get(
"profile_photo")
user_data["city"] = frappe.db.get_value("City", user_data["city"],
"city_name") or ""
user_data["location"] = frappe.db.get_value("Area", user_data["area"],
"area") or ""
user_data["dob"] = datetime.datetime.strftime(
getdate(user_data["dob"]), "%d-%m-%Y") if user_data["dob"] else ""
user_data.pop("area", None)
return {
"operation": "Search",
"message": "Profile Found",
"data": user_data,
"user_id": request_data.get("user_id")
}
except Exception, e:
print frappe.get_traceback()
raise e
raise GetUserProfileOperationFailed("User Profile Operation failed")
def get_project_details(request_data):
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
include_list = request_data.get("fields",[])
try:
es = ElasticSearchController()
response = es.search_document_for_given_id("project",request_data.get("project_id"), [], include_list)
return {"opeartion":"Search", "message":"Project details Found", "data":response}
except elasticsearch.TransportError:
raise DoesNotExistError("Project Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
def get_project_details(request_data):
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
include_list = request_data.get("fields",[])
try:
es = ElasticSearchController()
response = es.search_document_for_given_id("project",request_data.get("project_id"), [], include_list)
return {"opeartion":"Search", "message":"Project details Found", "data":response}
except elasticsearch.TransportError:
raise DoesNotExistError("Project Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
def get_property_of_given_id(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
try:
es = ElasticSearchController()
response = es.search_document_for_given_id("property",request_data.get("property_id"), ["property_photos"])
return {"operation":"Search", "message":"Property found" if len(response) else "Property Not Found", "user_id":request_data.get("user_id"), "data":response}
except elasticsearch.TransportError:
raise DoesNotExistError("Property Id does not exists")
except Exception,e:
raise GetPropertyOperationFailed("Get Property Operation Failed")
def create_property_seen_entry(data):
request_data = json.loads(data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["property_id"])
try:
pa = frappe.new_doc("Property Alerts")
pa.user_id =request_data.get("user_id")
pa.property_id = request_data.get("property_id")
pa.save(ignore_permissions=True)
return {"operation":"Create", "message":"Alert property {0} registered successfully.".format(request_data.get("property_id"))}
except Exception,e:
raise OperationFailed("Make Property alerts operation failed")
def update_property_fields(data):
request_data = json.loads(data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
try:
field_dict = get_updated_fields_dict(request_data, user_email)
search_query = {"doc": field_dict }
es = ElasticSearchController()
update_response = es.update_docuemnt("property", request_data.get("property_id"), search_query)
return {"opeartion":"Update", "message":"Property details Updated"}
except elasticsearch.TransportError:
raise DoesNotExistError("Property Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
def validate_data_before_property_posting(request_data):
"""
Validate property posting data, convert area to sqft
& other validatory tasks.
"""
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
subs_doc = putil.validate_for_postings_available(email)
putil.convert_area_to_sqft_for_posting(request_data)
putil.validate_property_status(request_data.get("status"))
property_data = putil.validate_property_posting_data(request_data,"property_json/property_mapper.json")
return property_data, email, subs_doc
def validate_data_before_property_posting(request_data):
"""
Validate property posting data, convert area to sqft
& other validatory tasks.
"""
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
subs_doc = putil.validate_for_postings_available(email)
putil.convert_area_to_sqft_for_posting(request_data)
putil.validate_property_status(request_data.get("status"))
property_data = putil.validate_property_posting_data(request_data,"property_json/property_mapper.json")
return property_data, email, subs_doc
def update_property_fields(data):
request_data = json.loads(data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
try:
field_dict = get_updated_fields_dict(request_data, user_email)
search_query = {"doc": field_dict }
es = ElasticSearchController()
update_response = es.update_docuemnt("property", request_data.get("property_id"), search_query)
return {"opeartion":"Update", "message":"Property details Updated"}
except elasticsearch.TransportError:
raise DoesNotExistError("Property Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
def get_property_contact(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
if not request_data.get("property_id"):
raise MandatoryError("Mandatory Field Property Id missing")
try:
es = ElasticSearchController()
response = es.search_document_for_given_id("property",request_data.get("property_id"),[],["agent_name", "agent_no", "contact_no" ,"contact_person"])
return {"operation":"Search", "message":"Contact Details found" if len(response) else "Contact Details Not Found", "user_id":request_data.get("user_id"), "data":response}
except elasticsearch.TransportError:
raise DoesNotExistError("Property Id does not exists")
except Exception,e:
raise OperationFailed("Get Property Contact Operation Failed")
def update_user_profile(data):
request_data = json.loads(data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
city = frappe.db.get_value("City",{ "city_name":request_data.get("city") ,"state_name":request_data.get("state")}, "name")
area = frappe.db.get_value("Area",{ "city_name":city ,"state_name":request_data.get("state"), "area":request_data.get("location")}, "name")
user_dict = {"first_name":request_data.get("first_name",""), "last_name":request_data.get("last_name",""), "mobile_no": request_data.get("mobile_number",""), "state": request_data.get("state",""), "city":city, "area":area, "address":request_data.get("address",""), "pincode":request_data.get("pin_code",""), "birth_date":request_data.get("dob",""),"lattitude":request_data.get("geo_location_lat"),"longitude":request_data.get("geo_location_lon")}
try:
# user_dict["user_image"] = store_image_to_propshikari(request_data)
user_doc = frappe.get_doc("User",user_email)
user_doc.update(user_dict)
user_doc.save(ignore_permissions=True)
return {"operation":"Update", "message":"Profile Updated Successfully", "user_id":request_data.get("user_id")}
except frappe.MandatoryError,e:
raise MandatoryError("Mandatory Field {0} missing".format(e.message))
def get_alerts(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
alert = frappe.db.sql("select * from `tabAlerts` where user_id='{0}' order by creation desc limit 1".format(request_data.get("user_id")),as_dict=1)
try:
if alert:
property_search_query = putil.generate_search_query(alert[0])
new_query = property_search_query.get("query").get("bool").get("must")
new_query.append({
"range" : {
"posted_datetime" : {
"gte": alert[0].get("creation").strftime("%Y-%m-%d %H:%M:%S"),
}
}
})
property_search_query["query"]["bool"]["must"] = new_query
else:
search_query = {
"sort": [{ "posted_datetime": { "order": "desc" }}],
"query":{ "bool":{ "must":[ {"match":{ "user_id":request_data.get("user_id") } } ] } }
}
es = ElasticSearchController()
response_data, total_records = es.search_document(["request"], search_query, 1, 1)
if response_data:
last_month_date = add_months(datetime.datetime.now() ,-1).strftime("%Y-%m-%d %H:%M:%S")
property_search_query = response_data[0].get("search_query")
property_search_query = ast.literal_eval(property_search_query.encode("utf8"))
new_query = property_search_query.get("query").get("bool").get("must")
new_query.append({
"range" : {
"posted_datetime" : {
"gte":last_month_date,
}
}
})
property_search_query["query"]["bool"]["must"] = new_query
else:
raise OperationFailed("No Alerts and Request Id found against User {0}".format(email))
es = ElasticSearchController()
response_data, total_records = es.search_document(["property"], property_search_query, request_data.get("page_number",1), request_data.get("records_per_page",40))
from_record = ((request_data.get("page_number",1) - 1) * cint(request_data.get("records_per_page",40)) + 1 )
response_msg = "Property Found" if response_data else "Property not found"
no_of_pages = math.ceil(flt(total_records)/request_data.get("records_per_page",40))
return {"operation":"Search", "message":response_msg ,"total_records":total_records,"records_per_page":request_data.get("records_per_page",40),"from_record":from_record ,"to_record": from_record + len(response_data) - 1 if response_data else from_record + request_data.get("records_per_page",40) - 1 ,"data":response_data, "user_id":request_data.get("user_id"), "no_of_pages":no_of_pages}
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise e
def get_property_images(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
if not request_data.get("property_id"):
raise MandatoryError("Property Id not provided")
try:
es = ElasticSearchController()
response = es.search_document_for_given_id("property",request_data.get("property_id"),[],["full_size_images", "thumbnails"])
return { "operation":"Search", "message":"Property Images Found" if response else "Property Images Not Found", "user_id":request_data.get("user_id"), "data":response }
except elasticsearch.TransportError:
raise DoesNotExistError("Property Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Get Property Images Operation Failed")
def get_user_properties(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
search_query = { "query": { "match":{ "posted_by":request_data.get("user_id") } } }
try:
es = ElasticSearchController()
response_data, total_records = es.search_document(["property"], search_query, request_data.get("page_number",1), request_data.get("records_per_page",40))
response_data = check_for_shortlisted_property(response_data, request_data.get("user_id"))
response_msg = "User Property Found" if len(response_data) else "User Property not found"
from_record = (request_data.get("page_number",1) - 1) * cint(request_data.get("records_per_page",40)) + 1
return {"operation":"Search", "message":response_msg ,"total_records":total_records, "records_per_page":request_data.get("records_per_page",40),"from_record":from_record ,"to_record": from_record + len(response_data) - 1 if response_data else from_record + request_data.get("records_per_page",40) - 1,"data":response_data, "user_id":request_data.get("user_id")}
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Get User Properties Operation Failed")
def get_property_images(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
if not request_data.get("property_id"):
raise MandatoryError("Property Id not provided")
try:
es = ElasticSearchController()
response = es.search_document_for_given_id("property",request_data.get("property_id"),[],["full_size_images", "thumbnails"])
return { "operation":"Search", "message":"Property Images Found" if response else "Property Images Not Found", "user_id":request_data.get("user_id"), "data":response }
except elasticsearch.TransportError:
raise DoesNotExistError("Property Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Get Property Images Operation Failed")
def upadate_project_status(request_data):
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["project_id"])
try:
search_query = {"doc":{ "status":request_data.get("project_status") }}
es = ElasticSearchController()
response = es.update_docuemnt("project", request_data.get("project_id"), search_query)
return {
"operation":"Update" ,
"message":"Project status changed" if response else "Project Status not changed",
"user_id":request_data.get("user_id")
}
except elasticsearch.TransportError:
raise DoesNotExistError("Project Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
def upadate_project_status(request_data):
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["project_id"])
try:
search_query = {"doc":{ "status":request_data.get("project_status") }}
es = ElasticSearchController()
response = es.update_docuemnt("project", request_data.get("project_id"), search_query)
return {
"operation":"Update" ,
"message":"Project status changed" if response else "Project Status not changed",
"user_id":request_data.get("user_id")
}
except elasticsearch.TransportError:
raise DoesNotExistError("Project Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
def search_group_with_given_criteria(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
try:
es = ElasticSearchController()
response = es.search_document_for_given_id("request",request_data.get("request_id"))
group_search_conditions = make_conditions_for_group_search(response)
group_result = frappe.db.sql(""" select name as group_id, operation, property_type , property_subtype , ifnull(property_subtype_option,"") as property_subtype_option ,ifnull(location,"") as location, ifnull(city,"") as city, ifnull(min_budget,"") as min_budget, ifnull(max_budget,"") as max_budget, ifnull(min_area,"") as min_area, ifnull(max_area,"") as max_area from `tabGroup` {0} """.format(group_search_conditions),as_dict=True)
for group in group_result:
join_flag = frappe.db.get_value("Group User" , {"group_id":group.get("group_id"), "user_id":request_data.get("user_id")},"name")
group["user_joined"] = 1 if join_flag else 0
return {"operation":"Search", "request_id":request_data.get("request_id"), "data":group_result, "message":"Matching Groups Found" if len(group_result) else "Group Not Found" }
except elasticsearch.TransportError:
raise DoesNotExistError("Request Id does not exists")
except Exception,e:
return SearchGroupOperationFailed("Search Group Operation Failed")
def get_project_of_given_id(request_data):
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
if not request_data.get("project_id"):
raise MandatoryError("Project id does not exists")
try:
exclude_list = putil.get_exclude_list_for_search("Hunterscamp")
es = ElasticSearchController()
response = es.search_document_for_given_id("project", request_data.get("project_id"), exclude_list)
response_data = putil.get_date_diff_and_count_from_posting([response])
# putil.show_amenities_with_yes_status(response_data)
return {"operation":"Search", "message":"Project details found" if len(response) else "Project Not Found", "user_id":request_data.get("user_id"), "data":response_data[0]}
except elasticsearch.TransportError:
raise DoesNotExistError("Project Id does not exists")
except Exception,e:
raise OperationFailed("Get Project Operation Failed")
def remove_shortlisted_property(request_data):
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
if not request_data.get("property_id"):
raise MandatoryError("Mandatory Field Property Id missing")
sp_nm = frappe.db.get_value("Shortlisted Property", {"user_id":request_data.get("user_id"), "property_id":request_data.get("property_id"), "status":"Active"}, "name")
if sp_nm:
sp_doc = frappe.get_doc("Shortlisted Property", sp_nm)
sp_doc.status = "Inactive"
sp_doc.save(ignore_permissions=True)
return {
"operation":"Update",
"message":"Shortlisted Property removed successfully",
"user_id":request_data.get("user_id")
}
else:
raise DoesNotExistError("Property Id is not shortlised against user.")
def update_mascot_status(data):
request_data = json.loads(data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
validate_mascot_source(request_data)
mascot_dict = validate_mascot_data(request_data.get("mascot_list"))
mobile_dict = {"mobile_shortlist_status":"shortlist_status", "mobile_alert_status":"alert_status"}
fields = {
"website":mascot_dict,
"mobile":{ mobile_field:mascot_dict.get(mascot_field) for mobile_field, mascot_field in mobile_dict.items() if mascot_dict.has_key(mascot_field) }
}
try:
ms = frappe.get_doc("Mascot Status", {"user_id":request_data.get("user_id")})
ms.update(fields.get(request_data.get("mascot_source")))
ms.save(ignore_permissions=True)
return {"user_id":request_data.get("user_id"), "message":"Mascot Status Updated Successfully"}
except Exception,e:
return {"user_id":request_data.get("user_id"), "message":"Mascot status not found against user {0}".format(user_email)}
def update_project(request_data):
user_email = putil.validate_for_user_id_exists(request_data.get("fields").get("user_id"))
try:
field_dict = putil.validate_property_posting_data(request_data.get("fields"), "property_json/project_post_mapper.json")
get_modified_datetime(field_dict, user_email)
es = ElasticSearchController()
update_project_photos(field_dict, request_data.get("fields"), request_data.get("project_id"), es)
field_dict["possession_status"] = "Immediate" if field_dict.get("possession") else field_dict.get("possession_date")
search_query = {"doc": field_dict }
update_response = es.update_docuemnt("project", request_data.get("project_id"), search_query)
percent_script = get_percent_completion_script(project_mandatory_fields)
per_response = es.update_docuemnt("project", request_data.get("project_id"), percent_script)
return {"opeartion":"Update", "message":"Project details Updated"}
except elasticsearch.TransportError:
raise DoesNotExistError("Project Id does not exists")
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
def create_property_seen_entry(data):
request_data = json.loads(data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["property_id"])
try:
pa = frappe.new_doc("Property Alerts")
pa.user_id = request_data.get("user_id")
pa.property_id = request_data.get("property_id")
pa.save(ignore_permissions=True)
return {
"operation":
"Create",
"message":
"Alert property {0} registered successfully.".format(
request_data.get("property_id"))
}
except Exception, e:
raise OperationFailed("Make Property alerts operation failed")
def create_feedback(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data, ["request_type", "feedback"])
try:
fdbk = frappe.new_doc("Feedback")
fdbk.property_id = request_data.get("property_id")
fdbk.request_type = request_data.get("request_type")
fdbk.user_feedback = request_data.get("feedback")
fdbk.user_ratings = request_data.get("ratings")
fdbk.user_id = request_data.get("user_id")
fdbk.save()
return {"operation":"Create", "message":"Feedback Submitted"}
except frappe.MandatoryError,e:
raise MandatoryError("Mandatory Field {0} missing".format(e.message))
except (frappe.LinkValidationError, frappe.ValidationError) as e:
raise InvalidDataError(e.message)
def validate_for_session_exists(request_data):
request_data = json.loads(request_data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
sessions_status = frappe.db.get_value("Sessions", {
"user": user_email,
"sid": request_data.get("sid")
}, "status")
if sessions_status == "Active":
return {
"operation": "search",
"session_expired": False,
"message": "Session exists against user {0}".format(user_email)
}
else:
return {
"operation": "search",
"session_expired": True,
"message": "Session does not exists"
}
def update_user_profile(data):
request_data = json.loads(data)
user_email = putil.validate_for_user_id_exists(request_data.get("user_id"))
city = frappe.db.get_value(
"City", {
"city_name": request_data.get("city"),
"state_name": request_data.get("state")
}, "name")
area = frappe.db.get_value(
"Area", {
"city_name": city,
"state_name": request_data.get("state"),
"area": request_data.get("location")
}, "name")
dob = getdate(getdate(
request_data.get("dob")).strftime("%d-%m-%y")) if request_data.get(
"dob", "") else ""
user_dict = {
"first_name": request_data.get("first_name", ""),
"last_name": request_data.get("last_name", ""),
"mobile_no": request_data.get("mobile_number", ""),
"state": request_data.get("state", ""),
"city": city,
"area": area,
"address": request_data.get("address", ""),
"pincode": request_data.get("pincode", ""),
"birth_date": dob,
"lattitude": request_data.get("geo_location_lat"),
"longitude": request_data.get("geo_location_lon")
}
try:
# user_dict["user_image"] = store_image_to_propshikari(request_data)
user_doc = frappe.get_doc("User", user_email)
user_doc.update(user_dict)
user_doc.save(ignore_permissions=True)
return {
"operation": "Update",
"message": "Profile Updated Successfully",
"user_id": request_data.get("user_id")
}
except frappe.MandatoryError, e:
raise MandatoryError("Mandatory Field {0} missing".format(e.message))
def get_all_projects(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
search_query = { }
try:
include_list = ["project_id", "project_name"]
es = ElasticSearchController()
size = get_count_of_project_records(es)
response_data, total_records = es.search_document(["project"], search_query, request_data.get("page_number",1), size, [], include_list)
# response data & pagination logic
msg = "Projects Found" if len(response_data) else "Projects not found"
return putil.init_pagination_and_response_generatrion(request_data, response_data, msg, total_records)
except elasticsearch.ElasticsearchException,e:
raise ElasticSearchException(e.error)
except Exception,e:
raise OperationFailed("Get All Projects Operation Failed")
def create_feedback(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data,
["request_type", "feedback"])
try:
fdbk = frappe.new_doc("Feedback")
fdbk.property_id = request_data.get("property_id")
fdbk.request_type = request_data.get("request_type")
fdbk.user_feedback = request_data.get("feedback")
fdbk.user_ratings = request_data.get("ratings")
fdbk.user_id = request_data.get("user_id")
fdbk.save()
return {"operation": "Create", "message": "Feedback Submitted"}
except frappe.MandatoryError, e:
raise MandatoryError("Mandatory Field {0} missing".format(
e.message))
except (frappe.LinkValidationError, frappe.ValidationError) as e:
raise InvalidDataError(e.message)
def join_user_with_group_id(request_data):
if request_data:
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
putil.validate_property_data(request_data,["user_id","group_id"])
if not frappe.db.get_value("Group",{"name":request_data.get("group_id")},"name"):
raise DoesNotExistError("Group ID {0} does not exists".format(request_data.get("group_id")))
if frappe.db.get_value("Group User",{"group_id":request_data.get("group_id"), "user_id":request_data.get("user_id")},"name"):
raise DuplicateEntryError("Group {0} already joined".format(request_data.get("group_id")))
try:
grusr = frappe.new_doc("Group User")
grusr.user_id = request_data.get("user_id")
grusr.group_id = request_data.get("group_id")
grusr.user = email
grusr.save()
return {"operation":"Search", "message":"Group joined"}
except frappe.MandatoryError,e:
raise MandatoryError("Mandatory Field {0} missing".format(e.message))
except (frappe.LinkValidationError, frappe.ValidationError) as e:
raise InvalidDataError(e.message)
def remove_shortlisted_property(request_data):
request_data = json.loads(request_data)
email = putil.validate_for_user_id_exists(request_data.get("user_id"))
if not request_data.get("property_id"):
raise MandatoryError("Mandatory Field Property Id missing")
sp_nm = frappe.db.get_value(
"Shortlisted Property", {
"user_id": request_data.get("user_id"),
"property_id": request_data.get("property_id"),
"status": "Active"
}, "name")
if sp_nm:
sp_doc = frappe.get_doc("Shortlisted Property", sp_nm)
sp_doc.status = "Inactive"
sp_doc.save(ignore_permissions=True)
return {
"operation": "Update",
"message": "Shortlisted Property removed successfully",
"user_id": request_data.get("user_id")
}
else:
raise DoesNotExistError("Property Id is not shortlised against user.")
