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_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 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 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 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 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_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 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 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.")