from appservices.common.util import *
from appservices.common.form_schemas import *
import math

regions = Blueprint("regions",__name__)
import re
# Add region
@regions.route("/add_region",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def add_region():
    data_status = {"responseStatus":0,"result":""}
    try:
        if not session.get("adminId"):
            flash("session expired.Please login again.","Regiondanger")
            return redirect("admin_login")
        
        adminId = session.get("adminId")
  
        csrf_token = request.form.get("csrf_token")
        latitude = request.form.get("latitude", "")
        longitude = request.form.get("longitude", "")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]

        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr

        actionDate=datetime.datetime.now()
        
        if request.method == "POST":
            regionName = request.form.get("regionName", "")
            regionType = request.form.get("regionType", "")

            jsonData = request.form.to_dict(flat=True)
            requestData = [jsonData]
            updatedrequestData = [jsonData]
            formRegion = RegionsForm()
            if formRegion.validate_on_submit():
                if regionName and regionType:
                    try:
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        if admin_queryset:
                            message=admin_queryset.userName+" "+regionName+" region created successfully!"
                            save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_region","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 

                        region_table = Regions(
                            adminId=adminId,
                            regionName=regionName,
                            regionType=regionType,
                            createdOn=datetime.datetime.now(),
                            status=1,
                        )
                        save_table = region_table.save()
                        regionId = str(save_table.id)

                        flash("Region saved successfully!","Regionsuccess")
                        data_status["responseStatus"]=1
                        return data_status
                    except Exception as e:
                        flash("Unable to save locations details!!","Regiondanger")
                        data_status["responseStatus"]=4
                        return data_status
                else:
                    data_status["responseStatus"]=2
                    data_status["result"]= "Required fields are missing!!"
                    return data_status
            else:
                data_status["result"] = formRegion.errors
                return data_status
        else:
            flash("Invalid request.","Regiondanger")
            data_status["responseStatus"]=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to save region!!"
        flash("Unable to save region!!","Regiondanger")
        data_status['responseStatus']=4
        return data_status

# Update region
@regions.route("/update_region",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def update_region():
    data_status = {"responseStatus":0,"result":""}
    if not session.get("adminId"):
        flash("session Expired.","Regiondanger")
        return redirect("admin_login")
    adminId=session.get("adminId")  
    
    csrf_token = request.form.get("csrf_token")
    latitude = request.form.get("latitude", "")
    longitude = request.form.get("longitude", "")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]
        
    existing_record = ""
    client_ip=0
    
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr
    
    actionDate=datetime.datetime.now()
    try:
        regionId = request.args.get("regionId","")
        if request.method == "POST":
            regionName = request.form.get("regionName","")
            regionType = request.form.get("regionType","")
            
            jsonData = request.form.to_dict(flat=True)
            formRegion = RegionsForm(request.form, current_id=regionId)

            if formRegion.validate_on_submit():
                if regionName and regionType:
                    region_queryset = Regions.objects(id=regionId).first()
                    existing_record = region_queryset.to_json()
                    message=region_queryset.adminId.userName+" "+regionName+" Region updated successfully!"
                    requestData=[existing_record]
                    updatedrequestData=[jsonData]
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_region","update",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
                    
                    if region_queryset:
                        region_queryset.update(
                            regionName=regionName,
                            regionType=regionType
                            )
                        flash("Region updated successfully!","Regionsuccess")
                        data_status["responseStatus"]=1
                        return data_status
                    else:
                        flash("Invaild id!!", "Regiondanger")
                        data_status["responseStatus"]=4
                        return data_status
                else:
                    data_status["responseStatus"]=2
                    data_status["result"]= "required fields are missing."
                    return data_status
            else:
                data_status["result"]= formRegion.errors
                return data_status
        else:
            flash("Invalid request.", "Regiondanger")
            data_status["responseStatus"]=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to update region!!"
        flash(error,"Regiondanger")
        data_status["responseStatus"]=4
        return data_status

# View All Regions
@regions.route("/regions_list",methods=["POST","GET"])
@adminid_access_token_required
def regions_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    
    regionsList = []
    countriesList = []
    statesList = []
    citiesList = []
    blocksList = []
    pincodesList = []
    totalBlocksList = []
    allRegionsList = []
 
    pagination = "",
    regionpage = "",
 
    countryPage ="",
    countryPagination="",
 
    statePagination="",
    cityPagination="",
    blockPagination="",
    pincodePagination="",
 
    RegionSnoCount=0
    CountriesSnoCount = 0
    pincodesSnoCount = 0
    StateSnoCount = 0
    citySnoCount = 0
    blockSnoCount =0
    
    regions_search_element = "",
    countries_search_element = "",
    states_search_element = "",
    cities_search_element = "",
    blocks_search_element = "", 
    pincodes_search_element = "",
 
    adminId = session.get("adminId")
 
    permissionsList = check_permissions(session.get("adminId"),"locationsPermissions")
    formRegion =  RegionsFormSearch(request.args)
     
    if "view" in permissionsList:
        try:
            redirectto = request.args.get('redirectto','Region')
            if redirectto:
                redirectval=redirectto
            else:
                redirectval="Region"

            regions_search_element =  request.args.get("regions_search_element", "")
            countries_search_element = request.args.get("countries_search_element", "").strip()
            states_search_element = request.args.get("states_search_element","").strip()
            cities_search_element = request.args.get("cities_search_element","").strip()
            blocks_search_element = request.args.get("blocks_search_element","").strip()
            pincodes_search_element = request.args.get("pincodes_search_element","").strip()

            ################# For Regions Data ##################
            
   
            regionpage = request.args.get(get_page_parameter("regionpage"), type=int, default=1)
            per_page = 20
            regionStart =  (regionpage - 1) * per_page
            total_count = 0
    
            filters = Q(status__in=[0, 1])
            regions_queryset =(
                Regions.objects(filters)
                .only("id", "regionName")
                .order_by("regionName")
            )
            allRegionsList = list(regions_queryset)
            
                
            if formRegion.validate(): 
                if regions_search_element and regions_search_element.strip():
                    filters &= (Q(regionName__icontains=regions_search_element.strip()) )
                total_count = Regions.objects(filters).count()
                temp = math.ceil(total_count/per_page)
                if regionpage>temp:
                    regionpage=1
                    regionStart = 0
                
                regions_queryset = (
                Regions.objects(filters)
                .only("id", "regionName", "regionType","status")
                .order_by("-id")
                .skip(regionStart)
                .limit(per_page)
                )

                RegionSnoCount = regionStart
                regionsList = list(regions_queryset)
                    
            else:
                regionsList=[]
            
            

                    
            RegionSnoCount  = regionStart
            pagination = Pagination(regionpage=regionpage, total=total_count,page_parameter="regionpage",per_page=per_page, alignment="right", record_name="Regions", href=f"?regions_search_element={regions_search_element}&regionpage={{0}}")
            ################# For Countries Data ##################
            # redirectto = request.args.get('redirectto','Country')
            # if redirectto:
            # 	redirectval=redirectto
            # else:
            # 	redirectval="Country"
            
            formCountries = CountriesFormSearch(request.args)
            regionId = request.args.get("regionId", "")
            filters = Q(status__in=[0, 1])

            # blocks_queryset =(
            #     BlocksPos.objects(filters)
            #     .only("id", "name")
            #     .order_by("name")
            # )
            # if blocks_queryset:
            # 	totalBlocksList = list(blocks_queryset)

            countryPage = request.args.get("countryPage", type=int, default=1)
            per_page = 20
            CountryStart = (countryPage - 1) * per_page
            total_count = 0

            if formCountries.validate():
                if countries_search_element:
                    filters &= Q(countryName__icontains=countries_search_element)
                    
                try:
                    total_count = Countries.objects(filters).count()
                    temp = math.ceil(total_count/per_page)
                    if countryPage>temp:
                        CountryStart = 0
                        countryPage = 1
                    countries_queryset = (
                        Countries.objects(filters)
                        .only("id", "countryName", "countryCode", "status", "regionId", "regex", "countryFlag")
                        .order_by("-id")
                        .skip(CountryStart)
                        .limit(per_page)
                    )
                    countriesList = list(countries_queryset)
                except Exception as e:
                    countriesList = []
                    total_count = 0
            else:
                countriesList = []
                total_count = 0

            CountriesSnoCount = CountryStart
            countryPagination = Pagination(
                countryPage=countryPage,
                total=total_count,
                page_parameter="countryPage",
                per_page=per_page,
                alignment="right",
                record_name="Countries",
                href=f"?redirectto=Country&countries_search_element={countries_search_element}&countryPage={{0}}"
            )


            ################# For States Data ##################
            formStates = StatesFormSearch(request.args)
            statePage = request.args.get(get_page_parameter('statePage'), type=int, default=1)
            per_page = 20
            stateStart =  (statePage - 1) * per_page
            total_count = 0
            filters = Q(status__in=[0, 1])

            if formStates.validate():
                if states_search_element:
                    filters &= Q(stateName__icontains=states_search_element)
                try:
                    total_count = States.objects(filters).count()
                    temp = math.ceil(total_count/per_page)
                    
                    if statePage>temp:
                        stateStart = 0
                        statePage = 1
                    states_queryset = (
                        States.objects(filters)
                        .only("id", "stateName","stateCode", "countryId","status")
                        .order_by("-id")
                        .skip(stateStart)
                        .limit(per_page)
                        )
                    statesList = list(states_queryset)
                except Exception as e:
                    statesList = []
                    total_count = 0
            else:
                statesList = []
                total_count =0
            StateSnoCount = stateStart
            statePagination = Pagination(statePage=statePage, total=total_count,page_parameter="statePage",per_page=per_page, alignment="right", record_name="States",href=f"?redirectto=State&states_search_element={states_search_element}&statePage={{0}}")


            ################# For Cities Data ##################
            formCities = CititesFormSearch(request.args)
            cityPage = request.args.get(get_page_parameter('cityPage'), type=int, default=1)
            city_per_page = 20  # Number of items per page
            city_start = (cityPage - 1) * city_per_page
            filters = Q(status__in=[0, 1])

            if formCities.validate():
                if cities_search_element:
                    filters &= Q(cityName__icontains=cities_search_element)
                try:
                    total_city_count = Cities.objects(filters).count()
                    temp = math.ceil(total_city_count/per_page)
                    if cityPage>temp:
                        city_start = 0
                        cityPage = 1
                    cities_queryset = (
                        Cities.objects(filters)
                        .only("id", "cityName", "stateId", "status")
                        .order_by("-id")
                        .skip(city_start)
                        .limit(per_page)
                    )
                    citiesList = list(cities_queryset)
                except Exception as e:
                    citiesList = []
                    total_city_count = 0
            else:
                citiesList = []
                total_city_count = 0
            citySnoCount = city_start
            cityPagination = Pagination(cityPage=cityPage, total=total_city_count,page_parameter="cityPage",per_page=city_per_page, alignment="right", record_name="Cities",href=f"?redirectto=City&cities_search_element={cities_search_element}&cityPage={{0}}")     

            
            ################# For Block/PO Data ##################

            formBlocks = BlocksFormSearch(request.args)
            blockPage = request.args.get(get_page_parameter('blockPage'), type=int, default=1)
            per_page = 20  # Number of items per page
            block_start = (blockPage - 1) * per_page
            filters = Q(status__in=[0, 1])
            total_count =0

            if formBlocks.validate():
                if blocks_search_element:
                    filters &= Q(name__icontains=blocks_search_element)
                    
                try:
                    total_count =  BlocksPos.objects(filters).count()
                    temp = math.ceil(total_count/per_page)
                    if blockPage>temp:
                        block_start =0
                        blockPage = 1
                    blocks_queryset = (
                        BlocksPos.objects(filters)
                        .only("id", "name","cityId", "status")
                        .order_by("-id")
                        .skip(block_start)
                        .limit(per_page)
                    )
                    blocksList = list(blocks_queryset)
                except Exception as e:
                    blocksList = []
                    total_count = 0
            else:
                blocksList = []
                total_count = 0
            blockSnoCount = block_start
            blockPagination = Pagination(blockPage=blockPage, total=total_count,page_parameter="blockPage",per_page=per_page, alignment="right", record_name="BlocksPos",href=f"?redirectto=Block&blocks_search_element={blocks_search_element}&blockPage={{0}}")

            
            ################# For Pincodes Data ##################
            formPincodes = PincodesFormSearch(request.args)
            pincodePage = request.args.get(get_page_parameter('pincodePage'), type=int, default=1)
            per_page = 20  # Number of items per page
            pincode_start = (pincodePage - 1) * per_page
            filters = Q(status__in=[0, 1])
            total_count = 0
            if formPincodes.validate():
                if pincodes_search_element:
                    filters &= Q(pincode=int(pincodes_search_element))
                try:
                    total_count =  Pincodes.objects(filters).count()
                    temp = math.ceil(total_count/per_page)
                    if pincodePage>temp:
                        pincode_start = 0
                        pincodePage = 1
                    pincodes_queryset =(
                        Pincodes.objects(filters)
                        .only("id","pincode", "blockPoId", "longitude", "latitude", "status")
                        .order_by("-id")
                        .skip(pincode_start)
                        .limit(per_page))
                    pincodesList = list(pincodes_queryset)
                except Exception as e:
                    pincodesList = []
                    total_count = 0
            else:
                pincodesList = []
                total_count = 0
            pincodesSnoCount = pincode_start
            pincodePagination = Pagination(pincodePage=pincodePage, total=total_count,page_parameter="pincodePage",per_page=per_page, alignment="right", record_name="Pincodes",href=f"?redirectto=Pincode&pincodes_search_element={pincodes_search_element}&pincodePage={{0}}")

            
            return render_template("super_admin_templates/country_master_list.html",
                domain=domain,
                pagination=pagination,
                countryPagination=countryPagination,
                statePagination=statePagination,
                cityPagination=cityPagination,
                blockPagination=blockPagination,
                pincodePagination=pincodePagination,
                regionsList=regionsList,
                countriesList=countriesList,
                statesList=statesList,
                citiesList=citiesList,
                blocksList=blocksList,
                pincodesList=pincodesList,
                totalBlocksList = totalBlocksList,
                regions_search_element=regions_search_element,
                countries_search_element=countries_search_element,
                states_search_element=states_search_element,
                cities_search_element=cities_search_element,
                blocks_search_element=blocks_search_element,
                pincodes_search_element=pincodes_search_element,
                redirectval=redirectval,
                regionpage = regionpage,
                RegionSnoCount=RegionSnoCount,
                countryPage = countryPage,
                CountriesSnoCount=CountriesSnoCount,
                formRegion = formRegion,
                formCountries = formCountries,
                formStates = formStates,
                StateSnoCount = StateSnoCount,
                formCities = formCities,
                citySnoCount = citySnoCount,
                formBlocks = formBlocks,
                blockSnoCount = blockSnoCount,
                pincodesSnoCount = pincodesSnoCount,
                formPincodes = formPincodes,
                statePage=statePage,
                cityPage = cityPage,
                blockPage= blockPage,
                pincodePage = pincodePage,
                allRegionsList=allRegionsList
                )
        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to fetch regions details!!"
            return render_template("super_admin_templates/country_master_list.html", 
                domain=domain,
                error=error,
                pagination=pagination,
                countryPagination=countryPagination,
                statePagination=statePagination,
                cityPagination=cityPagination,
                blockPagination=blockPagination,
                pincodePagination=pincodePagination,
                countriesList=countriesList,
                citiesList=citiesList,
                blocksList=blocksList,
                totalBlocksList=totalBlocksList,
                pincodesList=pincodesList,
                statesList=statesList,
                regionsList=regionsList,
                countries_search_element=countries_search_element,
                states_search_element=states_search_element,
                cities_search_element=cities_search_element,
                blocks_search_element=blocks_search_element,
                pincodes_search_element=pincodes_search_element,
                regions_search_element=regions_search_element,
                redirectval=redirectval,
                regionpage = regionpage,
                RegionSnoCount=RegionSnoCount,
                countryPage = countryPage,
                CountriesSnoCount=CountriesSnoCount,
                formRegion = formRegion,
                formCountries = formCountries,
                formStates = formStates,
                StateSnoCount = StateSnoCount,
                formCities = formCities,
                citySnoCount = citySnoCount,
                formBlocks = formBlocks,
                blockSnoCount = blockSnoCount,
                pincodesSnoCount = pincodesSnoCount,
                formPincodes = formPincodes,
                statePage=statePage,
                cityPage = cityPage,
                blockPage= blockPage,
                pincodePage = pincodePage,
                allRegionsList=allRegionsList
                )
    else:
        flash("The staff member does not have permission to view location.")
        return redirect(url_for("admin.dashboard"))

# Update regions type status
@regions.route("/update_region_type_status",methods=["POST","GET"])
@adminid_access_token_required
def update_region_type_status():
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId")
 
    regionpage = request.args.get("regionpage",  type=int, default=1)
    regions_search_element = request.args.get("regions_search_element")
    redirectTo=url_for("regions.regions_list",regionpage=regionpage,regions_search_element=regions_search_element)
    latitude = request.args.get("latitude", "")
    longitude = request.args.get("longitude", "")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]
    existing_record= ""
    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()

    jsonData = request.form.to_dict(flat=True)
    
    updatedrequestData = [jsonData]

    regionId = request.args.get("regionId","")

    if regionId:
        try:
            region_queryset = Regions.objects(id=regionId,status__nin=[2]).first()
            existing_record = region_queryset.to_json()
            requestData = [existing_record]
            if region_queryset:
                if region_queryset.status == 0:
                    region_queryset.update(status=1)
                    flash("Region activated successfully!","Regionsuccess")
                    message=region_queryset.adminId.userName+" "+region_queryset.regionName+" Region activated successfully!"
                elif region_queryset.status == 1:
                    region_queryset.update(status=0)
                    flash("Region deactivated successfully!","Regionsuccess")
                    message=region_queryset.adminId.userName+" "+region_queryset.regionName+" Region deactivated successfully!"
                save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_region_type_status","updatestatus",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
                return redirect(redirectTo)
            else:
                flash("Invaild id!!","Regiondanger")
                return redirect(redirectTo)
        except Exception as e:
            flash("Unable to update the status","Regiondanger")
            app.logger.error(traceback.format_exc())
            return redirect(redirectTo)
    else:
        return redirect(redirectTo)

# Delete Region
@regions.route("/delete_region",methods=["GET"])
@adminid_access_token_required
def delete_region():
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId=session.get("adminId")    

        regionpage = request.args.get("regionpage",  type=int, default=1)
        regions_search_element = request.args.get("regions_search_element")
        redirectTo=url_for("regions.regions_list",regionpage=regionpage,regions_search_element=regions_search_element)
        latitude = request.args.get("latitude", "")
        longitude = request.args.get("longitude", "")
        
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]
        existing_record = ""
        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr

        actionDate=datetime.datetime.now()
        jsonData = request.form.to_dict(flat=True)
        
        updatedrequestData = [jsonData]

        if request.method == "GET":
            regionId = request.args.get("regionId","")
            region_queryset = Regions.objects(id=regionId,status__in=[0,1]).first()
            existing_record = region_queryset.to_json()
            requestData = [existing_record]
            region_queryset.update(status=2)
            flash("Region deleted successfully!", "Regionsuccess")
            message=region_queryset.adminId.userName+" "+region_queryset.regionName+" Region deleted successfully!"
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"delete_region","delete",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
            return redirect(redirectTo)
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to delete region!!", "Regiondanger")
        return redirect(redirectTo)

def fetching_csv_regions_details(region_queryset):
    region_dict = {}
    try:
        if region_queryset.regionName:
            region_dict["Region Name"] = region_queryset.regionName
        else:
            region_dict["Region Name"] = ""

        if region_queryset.regionType:
            region_dict["Region Type"] = region_queryset.regionType
        else:
            region_dict["Region Type"] = ""        

        if region_queryset.status == 1:
            region_dict["Status"] = "Active"
        else:
            region_dict["Status"] = "In-Active"
    except Exception as e:
        app.logger.error(traceback.format_exc())
    return region_dict


@regions.route("/regions_csv_list",methods=["POST","GET"])
@adminid_access_token_required
def regions_csv_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    regionsList = []
    
    regionpage = request.args.get("regionpage")
    regions_search_element = request.args.get("regions_search_element")
    redirectTo=url_for("regions.regions_list",regionpage=regionpage,regions_search_element=regions_search_element)
    
    adminId = session.get("adminId")
    try:
        regions_queryset = Regions.objects(status__in=[0,1]).order_by("-id")

        for each_region in regions_queryset:
            region_dict = fetching_csv_regions_details(each_region)
            regionsList.append(region_dict)

        fieldnames = ['Region Name', 'Region Type', 'Status']
        temp_csv_file_name = "/media/regions_csv_files/"+str(round(time.time() * 1000))+".csv"

        if not os.path.exists(os.path.join(app.config['SITE_ROOT'], "media/regions_csv_files/")):
            os.makedirs(os.path.join(app.config['SITE_ROOT'], "media/regions_csv_files/"))

        full_file_name = app.config['SITE_ROOT']+temp_csv_file_name
        with open(full_file_name, 'w', encoding='UTF8', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(regionsList)
        save_csv_file = CSVFileExports(
            name=temp_csv_file_name,
            filters=[],
            createdOn=datetime.datetime.now(),
            status=1
            ).save()
        csvFileId = str(save_csv_file.id)

        return send_file(
            app.config['SITE_ROOT']+temp_csv_file_name,
            mimetype='text/csv',
            download_name='Regions list.csv',
            as_attachment=True
        )
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to export CSV data!!")
        return redirect(redirectTo)


############################ Countries ################################

@regions.route("/add_country",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def add_country():
    data_status = {"responseStatus":0,"result":""}
    try:
        if not session.get("adminId"):
            flash("session expired.Please login again.","danger")
            data_status["responseStatus"]=4
            return data_status
        adminId = session.get("adminId")
        
        csrf_token = request.form.get("csrf_token")
        latitude = request.form.get("latitude", "")
        longitude = request.form.get("longitude", "")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]
            
        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr
        
        actionDate=datetime.datetime.now()
        
        if request.method == "POST":
            countryName = request.form.get("countryName","")
            countryCode = request.form.get("countryCode","")
            regionId = request.form.get("regionId","")
            regex = request.form.get("regex","")
            countryFlag = request.files.get("countryFlag")            
            jsonData = request.form.to_dict(flat=True)
            requestData = [jsonData]
            updatedrequestData = [jsonData]
            
            form = CountriesForm()
            if form.validate_on_submit():
                if countryName and countryCode and regionId and regex:
                    try:
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        if admin_queryset:
                            message=admin_queryset.userName+" "+countryName+" country created successfully!"
                            save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_country","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
                        
                        country_table = Countries(
                            adminId=adminId,
                            countryName = countryName,
                            countryCode = countryCode,
                            regionId = regionId,
                            regex = regex,
                            createdOn = datetime.datetime.now(),
                            status = 1,
                            )
                        save_table = country_table.save()
                        countryId = str(save_table.id)
                            
                        
                        if countryFlag:
                            if not os.path.exists(os.path.join(app.config['SITE_ROOT'], "media/countries/")):
                                os.makedirs(os.path.join(app.config['SITE_ROOT'], "media/countries/"))
                            save_file = countryFlag.save(os.path.join(app.config['SITE_ROOT'], "media/countries/"+countryId+".png"))
                            save_table.update(countryFlag="media/countries/"+countryId+".png")
                        
                        flash("Country saved successfully!",'Countrysuccess')
                        data_status["responseStatus"]=1
                        return data_status
                    
                    except Exception as e:
                        flash("Unable to save country!!","Countrydanger")
                        data_status["responseStatus"]=4
                        return data_status
                else: 
                    data_status["responseStatus"]=2
                    data_status['result']="Required fields are missing!!"
                    return data_status
            else:
                data_status['result']=form.errors
                return data_status
        else:
            flash("Invalid request.","Countrydanger")
            data_status['responseStatus']=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to save country!!"
        flash(error,"Countrydanger")
        data_status["responseStatus"]=4
        return data_status
    
    
# Update country
@regions.route("/update_country",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def update_country():
    data_status={"responseStatus":0,"result":""}
    if not session.get("adminId"):
        flash("session Expired.")
        data_status["responseStatus"]=4
        return data_status
    adminId=session.get("adminId")  
    
    csrf_token = request.form.get("csrf_token")
    latitude = request.form.get("latitude", "")
    longitude = request.form.get("longitude", "")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]
    
    existing_record = ""
    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr
        
    actionDate=datetime.datetime.now()
    
    try:
        countryId = request.args.get("countryId","")
        if request.method == "POST":
            countryName = request.form.get("countryName","")
            countryCode = request.form.get("countryCode","")
            regex = request.form.get("regex","")
            regionId = request.form.get("regionId","")
            countryFlag = request.files.get("countryFlag")
            
            jsonData = request.form.to_dict(flat=True)
            form = CountriesForm(request.form, current_id=countryId)
            
            if form.validate_on_submit():
                if countryName and countryCode and regionId and regex:
                    country_queryset = Countries.objects(id=countryId).first()
                    existing_record = country_queryset.to_json()
                    message=country_queryset.adminId.userName+" "+countryName+" country updated successfully!"
                    requestData=[existing_record]
                    updatedrequestData=[jsonData]
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_country","update",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                    
                    if country_queryset:
                        country_queryset.update(
                        countryName=countryName,
                        countryCode=countryCode,
                        regex=regex,
                        regionId=ObjectId(regionId)
                        )
                        if countryFlag:
                            randomUniqueId = str(random_digit_generate(15))
                            if not os.path.exists(os.path.join(app.config['SITE_ROOT'], "media/countries/")):
                                os.makedirs(os.path.join(app.config['SITE_ROOT'], "media/countries/"))
                            save_file = countryFlag.save(os.path.join(app.config['SITE_ROOT'], "media/countries/"+randomUniqueId+".png"))
                            country_queryset.update(countryFlag="media/countries/"+randomUniqueId+".png")
                        
                        flash("country updated successfully!","Countrysuccess")
                        data_status["responseStatus"]=1
                        return data_status
                    else:
                        flash("Invaild id!!","Countrydanger")
                        data_status["responseStatus"]=4
                        return data_status
                else:
                    data_status["responseStatus"]=2
                    data_status["result"]= "required fields are missing."
                    return data_status
            else:
                data_status["result"]= form.errors
                return data_status
        else:
            flash("Invalid request.","Countrydanger")
            data_status["responseStatus"]=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to update countries!!"
        flash(error,"Countrydanger")
        data_status["responseStatus"]=4
        return data_status


# Update countries type status
@regions.route("/update_country_type_status",methods=["POST","GET"])
@adminid_access_token_required
def update_country_type_status():
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId")
    
    countryPage = request.args.get("countryPage",  type=int, default=1)
    countries_search_element = request.args.get("countries_search_element")
    redirectTo=url_for("regions.regions_list",countryPage=countryPage,countries_search_element=countries_search_element,redirectto='Country')
    latitude = request.args.get("latitude", "")
    longitude = request.args.get("longitude", "")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]
    existing_record = ""
    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()

    jsonData = request.form.to_dict(flat=True)
    
    updatedrequestData = [jsonData]

    countryId = request.args.get("countryId","")

    if countryId:
        try:
            country_queryset = Countries.objects(id=countryId,status__nin=[2]).first()
            existing_record = country_queryset.to_json()
            requestData = [existing_record]
            if country_queryset:
                if country_queryset.status == 0:
                    country_queryset.update(status=1)
                    flash("country activated successfully!","Countrysuccess")
                    message=country_queryset.adminId.userName+" "+country_queryset.countryName+" country activated successfully!"
                elif country_queryset.status == 1:
                    country_queryset.update(status=0)
                    flash("country deactivated successfully!","Countrysuccess")
                    message=country_queryset.adminId.userName+" "+country_queryset.countryName+" country deactivated successfully!"
                save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_country_type_status","updatestatus",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
                return redirect(redirectTo)
            else:
                flash("Invaild id!!","Countrydanger")
                return redirect(redirectTo)
        except Exception as e:
            app.logger.error(traceback.format_exc())
            return redirect(redirectTo)
    else:
        return redirect(redirectTo)


# Delete country
@regions.route("/delete_country",methods=["GET"])
@adminid_access_token_required
def delete_country():
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId=session.get("adminId")
  
        countryPage = request.args.get("countryPage",  type=int, default=1)
        countries_search_element = request.args.get("countries_search_element")
        redirectTo=url_for("regions.regions_list",countryPage=countryPage,countries_search_element=countries_search_element,redirectto="Country")
        latitude = request.args.get("latitude", "")
        longitude = request.args.get("longitude", "")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]

        existing_record = ""
        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr

        actionDate=datetime.datetime.now()

        jsonData = request.form.to_dict(flat=True)
        
        updatedrequestData = [jsonData]

        if request.method == "GET":
            countryId = request.args.get("countryId","")
            country_queryset = Countries.objects(id=countryId,status__in=[0,1]).first()
            existing_record = country_queryset.to_json()
            requestData = [existing_record]
            country_queryset.update(status=2)
            flash("country deleted successfully!","Countrysuccess")
            message=country_queryset.adminId.userName+" "+country_queryset.countryName+" country deleted successfully!"
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"delete_country","delete",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
            return redirect(redirectTo)
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to delete country!!","Countrydanger")
        return redirect(redirectTo)


def fetching_csv_countries_details(country_queryset):
    country_dict = {}
    try:
        if country_queryset.countryName:
            country_dict["Country Name"] = country_queryset.countryName
        else:
            country_dict["Country Name"] = ""

        if country_queryset.regionId.regionName:
            country_dict["Region Name"] = country_queryset.regionId.regionName
        else:
            country_dict["Region Name"] = ""        

        if country_queryset.regex:
            country_dict["Regex"] = country_queryset.regex
        else:
            country_dict["Regex"] = ""

        if country_queryset.countryCode:
            country_dict["Country Code"] = country_queryset.countryCode
        else:
            country_dict["Country Code"] = ""

        if country_queryset.status == 1:
            country_dict["Status"] = "Active"
        else:
            country_dict["Status"] = "In-Active"
    except Exception as e:
        app.logger.error(traceback.format_exc())
    return country_dict


@regions.route("/countries_csv_list",methods=["POST","GET"])
@adminid_access_token_required
def countries_csv_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    countriesList = []
    
    adminId = session.get("adminId")
    try:
        countries_queryset = Countries.objects(status__in=[0,1]).order_by("-id")
        for each_country in countries_queryset:
            country_dict = fetching_csv_countries_details(each_country)
            countriesList.append(country_dict)


        fieldnames = ['Country Name', 'Region Name', 'Regex', 'Country Code','Status']
        temp_csv_file_name = "/media/countries_csv_files/"+str(round(time.time() * 1000))+".csv"

        if not os.path.exists(os.path.join(app.config['SITE_ROOT'], "media/countries_csv_files/")):
            os.makedirs(os.path.join(app.config['SITE_ROOT'], "media/countries_csv_files/"))

        full_file_name = app.config['SITE_ROOT']+temp_csv_file_name
        with open(full_file_name, 'w', encoding='UTF8', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(countriesList)
        save_csv_file = CSVFileExports(
            name=temp_csv_file_name,
            filters=[],
            createdOn=datetime.datetime.now(),
            status=1
            ).save()
        csvFileId = str(save_csv_file.id)

        return send_file(
            app.config['SITE_ROOT']+temp_csv_file_name,
            mimetype='text/csv',
            download_name='Countries list.csv',
            as_attachment=True
        )
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to export CSV data!!")
        return redirect("regions.regions_list",redirectto="Country")



############################ States ##############################

@regions.route("/add_state",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def add_state():
    data_status = {"responseStatus":0,"result":""}
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId = session.get("adminId")
  
        csrf_token = request.form.get("csrf_token")

        latitude = request.form.get("latitude", "")
        longitude = request.form.get("longitude", "")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]

        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr

        actionDate=datetime.datetime.now()

        if request.method == "POST":
            stateName = request.form.get("stateName","")
            countryId = request.form.get("countryId","")
            stateCode = request.form.get("stateCode","")

            jsonData = request.form.to_dict(flat=True)
            requestData = [jsonData]
            updatedrequestData = [jsonData]
            formState = StatesForm()
            if formState.validate_on_submit():
                if stateName and countryId and stateCode:
                # if not is_valid_alphanumeric(stateName):
                # 	flash("State Name must contain only alphanumeric characters, spaces, and specific special characters: @#$()+_-/.")
                # 	return redirect(url_for("regions.regions_list",redirectto="State"))
                    try:
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        if admin_queryset:
                            message=admin_queryset.userName+" "+stateName+" state created successfully!"
                            save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_state","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)

                        state_table = States(
                            adminId=adminId,
                            stateName = stateName,
                            countryId = countryId,
                            stateCode=stateCode,
                            createdOn = datetime.datetime.now(),
                            status = 1,
                            )
                        save_table = state_table.save()
                        stateId = str(save_table.id)

                        flash("State saved successfully!","Statesuccess")
                        data_status["responseStatus"]=1
                        return data_status
                    except Exception as e:
                        flash("Unable to save state!!","Statedanger")
                        app.logger.error(traceback.format_exc())
                        data_status["responseStatus"]=4
                        return data_status
                else:
                    data_status["responseStatus"]=2
                    data_status['result']="Required fields are missing!!"
                    return data_status
            else:
                data_status['result']=formState.errors
                return data_status
        else:
            data_status['responseStatus']=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to save state!!"
        flash(error,"Statedanger")
        data_status["responseStatus"]=4
        return data_status


# Update state type status
@regions.route("/update_state_status",methods=["POST","GET"])
@adminid_access_token_required
def update_state_status():
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId")

    statePage = request.args.get("statePage",  type=int, default=1)
    states_search_element = request.args.get("states_search_element")
    redirectTo=url_for("regions.regions_list",redirectto="State",statePage=statePage,states_search_element=states_search_element)
    latitude = request.args.get("latitude", "")
    longitude = request.args.get("longitude", "")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]

    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()

    jsonData = request.form.to_dict(flat=True)

    existing_record = ""
    updatedrequestData = [jsonData]

    stateId = request.args.get("stateId","")

    if stateId:
        try:
            state_queryset = States.objects(id=stateId,status__nin=[2]).first()
            existing_record = state_queryset.to_json()
            requestData = [existing_record]
            if state_queryset:
                if state_queryset.status == 0:
                    state_queryset.update(status=1)
                    flash("State activated successfully!","Statesuccess")
                    message=state_queryset.adminId.userName+" "+state_queryset.stateName+" State activated successfully!"
                elif state_queryset.status == 1:
                    state_queryset.update(status=0)
                    flash("State deactivated successfully!","Statesuccess")
                    message=state_queryset.adminId.userName+" "+state_queryset.stateName+" State deactivated successfully!"
                save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_state_status","updatestatus",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)

                return redirect(redirectTo)
            else:
                flash("Invaild id!!","Statedanger")
                return redirect(redirectTo)
        except Exception as e:
            app.logger.error(traceback.format_exc())
            return redirect(redirectTo)
    else:
        return redirect(redirectTo)


# Update state
@regions.route("/update_state",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def update_state():
    data_status = {"responseStatus":0,"result":""}
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId")
 
    csrf_token = request.form.get("csrf_token")
    latitude = request.form.get("latitude", "")
    longitude = request.form.get("longitude", "")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]
    existing_record = ""
    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()

    try:
        stateId = request.args.get("stateId","")
        if request.method == "POST":
            stateName = request.form.get("stateName","")
            countryId = request.form.get("countryId","")
            stateCode = request.form.get("stateCode","")

            formState = StatesForm(request.form, current_id=stateId)
            if formState.validate_on_submit():
                if stateName and countryId and stateCode:

                    jsonData = request.form.to_dict(flat=True)

                    state_queryset = States.objects(id=stateId).first()
                    existing_record = state_queryset.to_json()

                    message=state_queryset.adminId.userName+" "+stateName+" State updated successfully!"
                    requestData=[existing_record]
                    updatedrequestData=[jsonData]
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_state","update",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)

                    if state_queryset:
                        state_queryset.update(
                            stateName=stateName,
                            countryId=ObjectId(countryId),
                            stateCode=stateCode
                            )
                        flash("State updated successfully!","Statesuccess")
                        data_status["responseStatus"]=1
                        return data_status
                    else:
                        flash("Invaild id!!","Statedanger")
                        data_status["responseStatus"]=4
                        return data_status
                else:
                    data_status["responseStatus"]=2
                    data_status["result"]= "required fields are missing."
                    return data_status
            else:
                data_status["result"]= formState.errors
                return data_status
        else:
            flash("Invalid request.","Statedanger")
            data_status["responseStatus"]=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to update state!!"
        flash(error,"Statedanger")
        data_status["responseStatus"]=4
        return data_status


# Delete state
@regions.route("/delete_state",methods=["GET"])
@adminid_access_token_required
def delete_state():
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId=session.get("adminId")  

        statePage = request.args.get("statePage",  type=int, default=1)
        states_search_element = request.args.get("states_search_element")
        redirectTo=url_for("regions.regions_list",redirectto="State",statePage=statePage,states_search_element=states_search_element)
        latitude = request.args.get("latitude", "")
        longitude = request.args.get("longitude", "")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]

        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr

        actionDate=datetime.datetime.now()
        jsonData = request.form.to_dict(flat=True)

        existing_record = ""
        updatedrequestData = [jsonData]

        if request.method == "GET":
            stateId = request.args.get("stateId","")
            state_queryset = States.objects(id=stateId,status__in=[0,1]).first()
            existing_record = state_queryset.to_json()
            requestData = [existing_record]
            state_queryset.update(status=2)
            flash("State deleted successfully!","Statesuccess")
            message=state_queryset.adminId.userName+" "+state_queryset.stateName+" State deleted successfully!"
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"delete_state","delete",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
            return redirect(redirectTo)
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to delete state!!","Statedanger")
        return redirect(redirectTo)



def fetching_csv_states_details(state_queryset):
    state_dict = {}
    try:
        if state_queryset.stateName:
            state_dict["State Name"] = state_queryset.stateName
        else:
            state_dict["State Name"] = ""

        if state_queryset.countryId.countryName:
            state_dict["Country Name"] = state_queryset.countryId.countryName
        else:
            state_dict["Country Name"] = ""

        if state_queryset.status == 1:
            state_dict["Status"] = "Active"
        else:
            state_dict["Status"] = "In-Active"
    except Exception as e:
        app.logger.error(traceback.format_exc())
    return state_dict


@regions.route("/states_csv_list",methods=["POST","GET"])
@adminid_access_token_required
def states_csv_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    statesList = []
    
    adminId = session.get("adminId")
    try:
        states_queryset = States.objects(status__in=[0,1]).order_by("-id")
        for each_state in states_queryset:
            state_dict = fetching_csv_states_details(each_state)
            statesList.append(state_dict)


        fieldnames = ['State Name', 'Country Name','Status']
        temp_csv_file_name = "/media/states_csv_files/"+str(round(time.time() * 1000))+".csv"

        if not os.path.exists(os.path.join(app.config['SITE_ROOT'], "media/states_csv_files/")):
            os.makedirs(os.path.join(app.config['SITE_ROOT'], "media/states_csv_files/"))

        full_file_name = app.config['SITE_ROOT']+temp_csv_file_name
        with open(full_file_name, 'w', encoding='UTF8', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(statesList)
        save_csv_file = CSVFileExports(
            name=temp_csv_file_name,
            filters=[],
            createdOn=datetime.datetime.now(),
            status=1
            ).save()
        csvFileId = str(save_csv_file.id)

        return send_file(
            app.config['SITE_ROOT']+temp_csv_file_name,
            mimetype='text/csv',
            download_name='States list.csv',
            as_attachment=True
        )
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to export CSV data!!")
        return redirect("regions.regions_list",redirectto="State")



############################ Cities ##############################

@regions.route("/add_city",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def add_city():
    data_status = {"responseStatus":0,"result":""}
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId = session.get("adminId")
  
        csrf_token = request.form.get("csrf_token")

        latitude = request.form.get("latitude", "")
        longitude = request.form.get("longitude", "")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]

        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr

        actionDate=datetime.datetime.now()

        if request.method == "POST":
            cityName = request.form.get("cityName","")
            stateId = request.form.get("stateId","")

            jsonData = request.form.to_dict(flat=True)
            requestData = [jsonData]
            updatedrequestData = [jsonData]

            formCity = CitiesForm()
            if formCity.validate_on_submit():
                if cityName and stateId:
                    try:
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        if admin_queryset:
                            message=admin_queryset.userName+" "+cityName+" City created successfully!"
                            save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_city","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                        city_table = Cities(
                            adminId=adminId,
                            cityName = cityName,
                            stateId = stateId,
                            createdOn = datetime.datetime.now(),
                            status = 1,
                            )
                        save_table = city_table.save()
                        cityId = str(save_table.id)

                        flash("City saved successfully!","Citysuccess")
                        data_status["responseStatus"]=1
                        return data_status
                    except Exception as e:
                        flash("Unable to save city!!","Citydanger")
                        app.logger.error(traceback.format_exc())
                        data_status["responseStatus"]=4
                        return data_status
                else:
                    data_status["responseStatus"]=2
                    data_status['result']="Required fields are missing!!"
                    return data_status
            else:
                data_status['result']=formCity.errors
                return data_status
        else:
            data_status['responseStatus']=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to save city!!"
        flash(error,"Citydanger")
        data_status["responseStatus"]=4
        return data_status


# Update city type status
@regions.route("/update_city_status",methods=["POST","GET"])
@adminid_access_token_required
def update_city_status():
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId")

    cityPage = request.args.get("cityPage",  type=int, default=1)
    cities_search_element = request.args.get("cities_search_element")
    redirectTo=url_for("regions.regions_list",redirectto="City",cityPage=cityPage,cities_search_element=cities_search_element)
    latitude = request.args.get("latitude", "")
    longitude = request.args.get("longitude", "")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]

    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()

    jsonData = request.form.to_dict(flat=True)
    existing_record = ""
    updatedrequestData = [jsonData]

    cityId = request.args.get("cityId","")

    if cityId:
        try:
            city_queryset = Cities.objects(id=cityId,status__nin=[2]).first()
            existing_record = city_queryset.to_json()
            requestData = [existing_record]
            if city_queryset:
                if city_queryset.status == 0:
                    city_queryset.update(status=1)
                    flash("City activated successfully!","Citysuccess")
                    message=city_queryset.adminId.userName+" "+city_queryset.cityName+" City activated successfully!"
                elif city_queryset.status == 1:
                    city_queryset.update(status=0)
                    flash("City deactivated successfully!","Citysuccess")
                    message=city_queryset.adminId.userName+" "+city_queryset.cityName+" City deactivated successfully!"
                save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_city_status","updatestatus",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
                return redirect(redirectTo)
            else:
                flash("Invaild id!!","Citydanger")
                return redirect(redirectTo)
        except Exception as e:
            app.logger.error(traceback.format_exc())
            return redirect(redirectTo)
    else:
        return redirect(redirectTo)


# Update city
@regions.route("/update_city",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def update_city():
    data_status = {"responseStatus":0,"result":""}
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId")   
    csrf_token = request.form.get("csrf_token")
    latitude = request.form.get("latitude", "")
    longitude = request.form.get("longitude", "")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]
    existing_record = ""
    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()

    try:
        cityId = request.args.get("cityId","")
        if request.method == "POST":
            cityName = request.form.get("cityName","")
            stateId = request.form.get("stateId","")

            formCity = CitiesForm(request.form, current_id=cityId)
            if formCity.validate_on_submit():
                if cityName and stateId:

                    jsonData = request.form.to_dict(flat=True)

                    city_queryset = Cities.objects(id=cityId).first()
                    existing_record = city_queryset.to_json()
                    message=city_queryset.adminId.userName+" "+cityName+" City updated successfully!"
                    requestData=[existing_record]
                    updatedrequestData=[jsonData]
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_city","update",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 

                    if city_queryset:
                        city_queryset.update(
                            cityName=cityName,
                            stateId=ObjectId(stateId)
                            )
                        flash("City updated successfully!","Citysuccess")
                        data_status["responseStatus"]=1
                        return data_status
                    else:
                        flash("Invaild id!!","Citydanger")
                        data_status["responseStatus"]=4
                        return data_status
                else:
                    data_status["responseStatus"]=2
                    data_status['result']="Required fields are missing!!"
                    return data_status
            else:
                data_status['result']=formCity.errors
                return data_status
        else:
            data_status['responseStatus']=4
            return data_status

    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to update city!!"
        data_status["responseStatus"]=4
        return data_status


# Delete city
@regions.route("/delete_city",methods=["GET"])
@adminid_access_token_required
def delete_city():
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId=session.get("adminId")
        
        cityPage = request.args.get("cityPage",  type=int, default=1)
        cities_search_element = request.args.get("cities_search_element")
        redirectTo=url_for("regions.regions_list",redirectto="City",cityPage=cityPage,cities_search_element=cities_search_element)
        latitude = request.args.get("latitude", "")
        longitude = request.args.get("longitude", "")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]

        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr

        actionDate=datetime.datetime.now()

        jsonData = request.form.to_dict(flat=True)
        existing_record = ""
        updatedrequestData = [jsonData]

        if request.method == "GET":
            cityId = request.args.get("cityId","")
            city_queryset = Cities.objects(id=cityId,status__in=[0,1]).first()
            existing_record = city_queryset.to_json()
            requestData = [existing_record]
            city_queryset.update(status=2)
            flash("City deleted successfully!","Citysuccess")
            message=city_queryset.adminId.userName+" "+city_queryset.cityName+" City deleted successfully!"
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"delete_city","delete",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
            return redirect(redirectTo)
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to delete city!!","Citydanger")
        return redirect(redirectTo)

def fetching_csv_cities_details(city_queryset):
    city_dict = {}
    try:
        if city_queryset.cityName:
            city_dict["City Name"] = city_queryset.cityName
        else:
            city_dict["City Name"] = ""

        if city_queryset.countryId.countryName:
            city_dict["State Name"] = city_queryset.stateId.stateName
        else:
            city_dict["State Name"] = ""

        if city_queryset.status == 1:
            city_dict["Status"] = "Active"
        else:
            city_dict["Status"] = "In-Active"
    except Exception as e:
        app.logger.error(traceback.format_exc())
    return city_dict


@regions.route("/cities_csv_list",methods=["POST","GET"])
@adminid_access_token_required
def cities_csv_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    citiesList = []
    
    adminId = session.get("adminId")
    try:
        cities_queryset = Cities.objects(status__in=[0,1]).order_by("-id")
        for each_city in cities_queryset:
            city_dict = fetching_csv_cities_details(each_city)
            citiesList.append(city_dict)


        fieldnames = ['City Name', 'State Name','Status']
        temp_csv_file_name = "/media/cities_csv_files/"+str(round(time.time() * 1000))+".csv"

        if not os.path.exists(os.path.join(app.config['SITE_ROOT'], "media/cities_csv_files/")):
            os.makedirs(os.path.join(app.config['SITE_ROOT'], "media/cities_csv_files/"))

        full_file_name = app.config['SITE_ROOT']+temp_csv_file_name
        with open(full_file_name, 'w', encoding='UTF8', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(citiesList)
        save_csv_file = CSVFileExports(
            name=temp_csv_file_name,
            filters=[],
            createdOn=datetime.datetime.now(),
            status=1
            ).save()
        csvFileId = str(save_csv_file.id)

        return send_file(
            app.config['SITE_ROOT']+temp_csv_file_name,
            mimetype='text/csv',
            download_name='Cities list.csv',
            as_attachment=True
        )
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to export CSV data!!")
        return redirect("regions.regions_list",redirectto="City")


############################ Block/PO ##############################

@regions.route("/add_block",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def add_block():
    data_status = {"responseStatus":0,"result":""}
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId = session.get("adminId")
  
        csrf_token = request.form.get("csrf_token")
        latitude = request.form.get("latitude", "")
        longitude = request.form.get("longitude", "")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]

        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr

        actionDate=datetime.datetime.now()

        adminId = session.get("adminId")
        if request.method == "POST":
            name = request.form.get("name","")
            cityId = request.form.get("cityId","")
            jsonData = request.form.to_dict(flat=True)
            requestData = [jsonData]
            updatedrequestData = [jsonData]

            formBlock = BlocksForm()
            if formBlock.validate_on_submit():
                if name and cityId:
                    # if not is_valid_alphanumeric(name):
                    #     flash("Name must contain only alphanumeric characters, spaces, and specific special characters: @#$()+_-/.")
                    #     return redirect(url_for("regions.regions_list",redirectto="Block"))
                    try:
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        if admin_queryset:
                            message=admin_queryset.userName+" "+name+" Block created successfully!"
                            save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_block","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 

                        block_table = BlocksPos(
                            adminId=adminId,
                            name = name,
                            cityId = cityId,
                            createdOn = datetime.datetime.now(),
                            status = 1,
                            )
                        save_table = block_table.save()
                        blockId = str(save_table.id)

                        flash("Block saved successfully!","Blocksuccess")
                        data_status["responseStatus"]=1
                        return data_status
                    except Exception as e:
                        flash("Unable to save block!!","Blockdanger")
                        app.logger.error(traceback.format_exc())
                        data_status["responseStatus"]=4
                        return data_status
                else:
                    data_status["responseStatus"]=2
                    data_status['result']="Required fields are missing!!"
                    return data_status
            else:
                data_status['result']=formBlock.errors
                return data_status
        else:
            data_status['responseStatus']=4
            return data_status

    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to save block!!"
        flash(error,"Blockdanger")
        data_status['responseStatus']=4
        return data_status



# Update block type status
@regions.route("/update_block_status",methods=["POST","GET"])
@adminid_access_token_required
def update_block_status():
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId")
    
    blockPage = request.args.get("blockPage",  type=int, default=1)
    blocks_search_element = request.args.get("blocks_search_element")
    redirectTo=url_for("regions.regions_list",redirectto="Block",blockPage=blockPage,blocks_search_element=blocks_search_element)
    latitude = request.args.get("latitude", "")
    longitude = request.args.get("longitude", "")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]

    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()

    jsonData = request.form.to_dict(flat=True)

    existing_record = ""
    updatedrequestData = [jsonData]

    blockId = request.args.get("blockId","")

    if blockId:
        try:
            block_queryset = BlocksPos.objects(id=blockId,status__nin=[2]).first()
            existing_record = block_queryset.to_json()
            requestData = [existing_record]
            if block_queryset:
                if block_queryset.status == 0:
                    block_queryset.update(status=1)
                    flash("Block activated successfully!","Blocksuccess")
                    message=block_queryset.adminId.userName+" "+block_queryset.name+" Block activated successfully!"
                elif block_queryset.status == 1:
                    block_queryset.update(status=0)
                    flash("Block deactivated successfully!","Blocksuccess")
                    message=block_queryset.adminId.userName+" "+block_queryset.name+" Block deactivated successfully!"
                save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_block_status","updatestatus",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
                return redirect(redirectTo)
            else:
                flash("Invaild id!!","Blockdanger")
                return redirect(redirectTo)
        except Exception as e:
            app.logger.error(traceback.format_exc())
            return redirect(redirectTo)
    else:
        return redirect(redirectTo)


# Update block
@regions.route("/update_block",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def update_block():
    data_status = {"responseStatus":0,"result":""}
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId")
 
    csrf_token = request.form.get("csrf_token")
    latitude = request.form.get("latitude", "")
    longitude = request.form.get("longitude", "")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]
    existing_record = ""
    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()
    try:
        blockId = request.args.get("blockId","")
        if request.method == "POST":
            name = request.form.get("name","")
            cityId = request.form.get("cityId","")

            formBlock = BlocksForm(request.form, current_id=blockId)
            if formBlock.validate_on_submit():
                if name and cityId:
                    jsonData = request.form.to_dict(flat=True)
                    block_queryset = BlocksPos.objects(id=blockId).first()
                    existing_record = block_queryset.to_json()
                    message=block_queryset.adminId.userName+" "+name+" Block updated successfully!"
                    requestData=[existing_record]
                    updatedrequestData=[jsonData]
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_block","update",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)

                    if block_queryset:
                        block_queryset.update(
                            name=name,
                            cityId=ObjectId(cityId)
                            )
                        flash("Block updated successfully!","Blocksuccess")
                        data_status["responseStatus"]=1
                        return data_status
                    else:
                        flash("Invaild id!!","Blockdanger")
                        data_status['responseStatus']=4
                        return data_status
                else:
                    data_status["responseStatus"]=2
                    data_status['result']="Required fields are missing!!"
                    return data_status
            else:
                data_status['result']=formBlock.errors
                return data_status
        else:
            data_status['responseStatus']=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to update Block!!"
        flash(error,"Blockdanger")
        return redirect(url_for("regions.regions_list",redirectto="Block"))


# Delete block
@regions.route("/delete_block",methods=["GET"])
@adminid_access_token_required
def delete_block():
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId=session.get("adminId")
        blockPage = request.args.get("blockPage",  type=int, default=1)
        blocks_search_element = request.args.get("blocks_search_element")
        redirectTo=url_for("regions.regions_list",redirectto="Block",blockPage=blockPage,blocks_search_element=blocks_search_element)
        latitude = request.args.get("latitude", "")
        longitude = request.args.get("longitude", "")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]

        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr

        actionDate=datetime.datetime.now()

        jsonData = request.form.to_dict(flat=True)

        existing_record = ""
        updatedrequestData = [jsonData]

        if request.method == "GET":
            blockId = request.args.get("blockId","")
            block_queryset = BlocksPos.objects(id=blockId,status__in=[0,1]).first()
            existing_record = block_queryset.to_json()
            requestData = [existing_record]
            block_queryset.update(status=2)
            flash("Block deleted successfully!","Blocksuccess")
            message=block_queryset.adminId.userName+" "+block_queryset.name+" Block deleted successfully!"
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"delete_block","delete",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
            return redirect(redirectTo)
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to delete block!!","Blockdanger")
        return redirect(redirectTo)


def fetching_csv_blocks_details(block_queryset):
    block_dict = {}
    try:
        if block_queryset.name:
            block_dict["Block/PO Name"] = block_queryset.name
        else:
            block_dict["Block/PO Name"] = ""

        if block_queryset.cityId.cityName:
            block_dict["City Name"] = block_queryset.cityId.cityName
        else:
            block_dict["City Name"] = ""

        if block_queryset.status == 1:
            block_dict["Status"] = "Active"
        else:
            block_dict["Status"] = "In-Active"
    except Exception as e:
        app.logger.error(traceback.format_exc())
    return block_dict


@regions.route("/blocks_csv_list",methods=["POST","GET"])
@adminid_access_token_required
def blocks_csv_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    blocksList = []
    
    adminId = session.get("adminId")
    try:
        blocks_queryset = BlocksPos.objects(status__in=[0,1]).order_by("-id")
        for each_block in blocks_queryset:
            block_dict = fetching_csv_blocks_details(each_block)
            blocksList.append(block_dict)


        fieldnames = ['Block/PO Name', 'City Name','Status']
        temp_csv_file_name = "/media/blocks_csv_files/"+str(round(time.time() * 1000))+".csv"

        if not os.path.exists(os.path.join(app.config['SITE_ROOT'], "media/blocks_csv_files/")):
            os.makedirs(os.path.join(app.config['SITE_ROOT'], "media/blocks_csv_files/"))

        full_file_name = app.config['SITE_ROOT']+temp_csv_file_name
        with open(full_file_name, 'w', encoding='UTF8', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(blocksList)
        save_csv_file = CSVFileExports(
            name=temp_csv_file_name,
            filters=[],
            createdOn=datetime.datetime.now(),
            status=1
            ).save()
        csvFileId = str(save_csv_file.id)

        return send_file(
            app.config['SITE_ROOT']+temp_csv_file_name,
            mimetype='text/csv',
            download_name='Blocks/PO list.csv',
            as_attachment=True
        )
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to export CSV data!!")
        return redirect("regions.regions_list",redirectto="Block")


############################ Pincodes ##############################

@regions.route("/add_pincode",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def add_pincode():
    data_status = {"responseStatus":0,"result":""}
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId = session.get("adminId")
  
        csrf_token = request.form.get("csrf_token")
        latitude = request.form.get("latitude", "")
        longitude = request.form.get("longitude", "")

        lat = request.form.get("lat", "")
        long = request.form.get("long", "")


        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]

        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr

        actionDate=datetime.datetime.now()
        
        if request.method == "POST":
            pincode = request.form.get("pincode")
            blockPoId = request.form.get("blockPoId","")
            latitude = request.form.get("latitude","")
            longitude = request.form.get("longitude","")


            lat = request.form.get("lat", "")
            long = request.form.get("long", "")
            # if pincode and not is_valid_numeric(pincode):
            #     flash("Pincode contain only numeric characters!")
            #     return redirect(url_for("regions.regions_list",redirectto="Pincode"))

            # if latitude and not is_valid_latitude(latitude):
            #     flash("Invalid latitude! Must be between -90 and 90, with up to 6 decimal places.")
            #     return redirect(url_for("regions.regions_list",redirectto="Pincode"))

            # if longitude and not is_valid_longitude(longitude):
            #     flash("Invalid longitude! Must be between -180 and 180, with up to 6 decimal places.")
            #     return redirect(url_for("regions.regions_list",redirectto="Pincode"))

            jsonData = request.form.to_dict(flat=True)
            requestData = [jsonData]
            updatedrequestData = [jsonData]
            formPincodes = PincodesForm(request.form)
            if formPincodes.validate_on_submit():
                if pincode and blockPoId:
                    try:
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        if admin_queryset:
                            message=admin_queryset.userName+" "+pincode+" Pincode created successfully!"
                            save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_pincode","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)

                        pincode_table = Pincodes(
                            adminId=adminId,
                            pincode = pincode,
                            blockPoId = blockPoId,
                            latitude = lat,
                            longitude = long,
                            createdOn = datetime.datetime.now(),
                            status = 1,
                            )
                        save_table = pincode_table.save()
                        pincodeId = str(save_table.id)

                        flash("Pincode saved successfully!","Pincodesuccess")
                        data_status["responseStatus"]=1
                        return data_status
                    except Exception as e:
                        flash("Unable to save pincode!!","Pincodedanger")
                        app.logger.error(traceback.format_exc())
                        data_status["responseStatus"]=4
                        return data_status

                else:
                    data_status["responseStatus"]=2
                    data_status['result']="Required fields are missing!!"
                    return data_status
            else:
                data_status['result']=formPincodes.errors
                return data_status
        else:
            data_status['responseStatus']=4
            return data_status

    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to save pincode!!"
        flash(error,"Pincodedanger")
        data_status['responseStatus']=4
        return data_status


# Update pincode status
@regions.route("/update_pincode_status",methods=["POST","GET"])
@adminid_access_token_required
def update_pincode_status():
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId")
    
    pincodePage = request.args.get("pincodePage",  type=int, default=1)
    pincodes_search_element = request.args.get("pincodes_search_element")
    redirectTo=url_for("regions.regions_list",redirectto="Pincode",pincodePage=pincodePage,pincodes_search_element=pincodes_search_element)
    latitude = request.args.get("latitude", "")
    longitude = request.args.get("longitude", "")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]

    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()

    jsonData = request.form.to_dict(flat=True)

    existing_record = ""
    updatedrequestData = [jsonData]

    pincodeId = request.args.get("pincodeId","")

    if pincodeId:
        try:
            pincode_queryset = Pincodes.objects(id=pincodeId,status__nin=[2]).first()
            existing_record = pincode_queryset.to_json()
            requestData = [existing_record]
            if pincode_queryset:
                admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                if pincode_queryset.status == 0:
                    pincode_queryset.update(status=1)
                    flash("Pincode activated successfully!","Pincodesuccess")
                    message=admin_queryset.userName+" "+str(pincode_queryset.pincode)+" Pincode activated successfully!"
                elif pincode_queryset.status == 1:
                    pincode_queryset.update(status=0)
                    flash("Pincode deactivated successfully!","Pincodesuccess")
                    message=admin_queryset.userName+" "+str(pincode_queryset.pincode)+" Pincode deactivated successfully!"
                save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_pincode_status","updatestatus",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
                return redirect(redirectTo)
            else:
                flash("Invaild id!!","Pincodedanger")
                return redirect(redirectTo)
        except Exception as e:
            app.logger.error(traceback.format_exc())
            return redirect(redirectTo)
    else:
        return redirect(redirectTo)


# Update city
@regions.route("/update_pincode",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def update_pincode():
    data_status = {"responseStatus":0,"result":""}
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId") 
    latitude = request.form.get("latitude", "")
    longitude = request.form.get("longitude", "")

    lat = request.form.get("lat", "")
    long = request.form.get("long", "")

    csrf_token = request.form.get("csrf_token")
     
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]
    existing_record = ""
    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()

    try:
        pincodeId = request.args.get("pincodeId","")
        if request.method == "POST":
            pincode = request.form.get("pincode","")
            latitude = request.form.get("latitude","")
            longitude = request.form.get("longitude","")
            blockPoId = request.form.get("blockPoId","")
            jsonData = request.form.to_dict(flat=True)

            lat = request.form.get("lat", "")
            long = request.form.get("long", "")

            # if pincode and not is_valid_numeric(pincode):
            #     flash("Pincode contain only numeric characters!")
            #     return redirect(url_for("regions.regions_list",redirectto="Pincode"))

            # if latitude and not is_valid_latitude(latitude):
            #     flash("Invalid latitude! Must be between -90 and 90, with up to 6 decimal places.")
            #     return redirect(url_for("regions.regions_list",redirectto="Pincode"))

            # if longitude and not is_valid_longitude(longitude):
            #     flash("Invalid longitude! Must be between -180 and 180, with up to 6 decimal places.")
            #     return redirect(url_for("regions.regions_list",redirectto="Pincode"))



            pincode_queryset = Pincodes.objects(id=pincodeId).first()
            existing_record = pincode_queryset.to_json()
            message=pincode_queryset.adminId.userName+" "+pincode+" Pincode updated successfully!"
            requestData=[existing_record]
            updatedrequestData=[jsonData]
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_pincode","update",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 

            formPincodes = PincodesForm(request.form, current_id=pincodeId)
            if formPincodes.validate_on_submit():
                if pincode and blockPoId:
                
                    if pincode_queryset:
                        pincode_queryset.update(
                            pincode=pincode,
                            latitude = lat,
                            longitude = long,
                            blockPoId=ObjectId(blockPoId)
                            )
                        flash("Pincode updated successfully!","Pincodesuccess")
                        data_status["responseStatus"]=1
                        return data_status
                    else:
                        flash("Invaild id!!","Pincodedanger")
                        data_status['responseStatus']=4
                        return data_status
                else:
                    data_status["responseStatus"]=2
                    data_status['result']="Required fields are missing!!"
                    return data_status
            else:
                data_status['result']=formPincodes.errors
                return data_status
        else:
            data_status['responseStatus']=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to update pincode!!"
        data_status['responseStatus']=4
        return data_status


# Delete pincode
@regions.route("/delete_pincode",methods=["GET"])
@adminid_access_token_required
def delete_pincode():
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId=session.get("adminId")

        pincodePage = request.args.get("pincodePage",  type=int, default=1)
        pincodes_search_element = request.args.get("pincodes_search_element")
        redirectTo=url_for("regions.regions_list",redirectto="Pincode",pincodePage=pincodePage,pincodes_search_element=pincodes_search_element)
        latitude = request.args.get("latitude", "")
        longitude = request.args.get("longitude", "")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]
        existing_record = ""
        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr

        actionDate=datetime.datetime.now()
        jsonData = request.form.to_dict(flat=True)
        
        updatedrequestData = [jsonData]

        if request.method == "GET":
            pincodeId = request.args.get("pincodeId","")
            pincode_queryset = Pincodes.objects(id=pincodeId,status__in=[0,1]).first()
            existing_record = pincode_queryset.to_json()
            requestData = [existing_record]
            pincode_queryset.update(status=2)
            flash("Pincode deleted successfully!","Pincodesuccess")
            message=pincode_queryset.adminId.userName+" "+str(pincode_queryset.pincode)+" Pincode deleted successfully!"
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"delete_pincode","delete",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
            return redirect(redirectTo)
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to delete pincode!!","Pincodedanger")
        return redirect(redirectTo)


def fetching_csv_pincode_details(pincode_queryset):
    pincode_dict = {}
    try:
        if pincode_queryset.pincode:
            pincode_dict["Pincode"] = pincode_queryset.pincode
        else:
            pincode_dict["Pincode"] = ""

        if pincode_queryset.blockPoId.name:
            pincode_dict["Block/Po Name"] = pincode_queryset.blockPoId.name
        else:
            pincode_dict["Block/Po Name"] = ""

        if pincode_queryset.status == 1:
            pincode_dict["Status"] = "Active"
        else:
            pincode_dict["Status"] = "In-Active"
    except Exception as e:
        app.logger.error(traceback.format_exc())
    return pincode_dict


@regions.route("/pincodes_csv_list",methods=["POST","GET"])
@adminid_access_token_required
def pincodes_csv_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    pincodesList = []
    
    adminId = session.get("adminId")
    try:
        pincodes_queryset = Pincodes.objects(status__in=[0,1]).order_by("-id")
        for each_pincode in pincodes_queryset:
            pincode_dict = fetching_csv_pincode_details(each_pincode)
            pincodesList.append(pincode_dict)


        fieldnames = ['Pincode', 'Block/Po Name','Status']
        temp_csv_file_name = "/media/pincodes_csv_files/"+str(round(time.time() * 1000))+".csv"

        if not os.path.exists(os.path.join(app.config['SITE_ROOT'], "media/pincodes_csv_files/")):
            os.makedirs(os.path.join(app.config['SITE_ROOT'], "media/pincodes_csv_files/"))

        full_file_name = app.config['SITE_ROOT']+temp_csv_file_name
        with open(full_file_name, 'w', encoding='UTF8', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(pincodesList)
        save_csv_file = CSVFileExports(
            name=temp_csv_file_name,
            filters=[],
            createdOn=datetime.datetime.now(),
            status=1
            ).save()
        csvFileId = str(save_csv_file.id)

        return send_file(
            app.config['SITE_ROOT']+temp_csv_file_name,
            mimetype='text/csv',
            download_name='Pincodes list.csv',
            as_attachment=True
        )
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to export CSV data!!")
        return redirect("regions.regions_list",redirectto="Pincode")

@regions.route("/get_regions_list",methods=["POST","GET"])
def get_regions_list():
    data_status = {"responseStatus":0,"result":""}
    if not session.get("adminId"):
        return redirect("admin_login")
    regions_list = []
    filters = Q(status__in=[0, 1])
    adminId = session.get("adminId")
    try:
        regions_queryset =(
                Regions.objects(filters)
                .only("id", "regionName")
                .order_by("regionName")
            )
        if regions_queryset:
            for each_region in regions_queryset:
                doc = each_region.to_mongo().to_dict()
                doc['id'] = str(doc.pop('_id'))
                regions_list.append(doc)

        data_status.update({
            "responseStatus":1,
            "result":regions_list
        })
        return data_status

    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["responseStatus"] = "Unable to fetch the Regions List!"
        return data_status

@regions.route("/get_countries_list", methods=["POST","GET"])
def get_countries_list():
    data_status = {"responseStatus":0,"result":""}
    if not session.get("adminId"):
        return redirect("admin_login")
    countries_list = []
    filters = Q(status__in=[0, 1])
    adminId = session.get("adminId")
    regionId = request.form.get("regionId","")
    try:
        if regionId:
            filters &= Q(regionId=regionId)
        countries_queryset =(
                Countries.objects(filters)
                .only("id", "countryName")
                .order_by("countryName")
            )
        if countries_queryset:
            for each_country in countries_queryset:
                doc = each_country.to_mongo().to_dict()
                doc['id'] = str(doc.pop('_id'))
                countries_list.append(doc)

        data_status.update({
            "responseStatus":1,
            "result":countries_list
        })
        return data_status

    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["responseStatus"] = "Unable to fetch the Countries List!"
        return data_status

@regions.route("/get_states_list", methods=["POST","GET"])
def get_states_list():
    data_status = {"responseStatus":0,"result":""}
    if not session.get("adminId"):
        return redirect("admin_login")
    states_list = []
    filters = Q(status__in=[0, 1])
    adminId = session.get("adminId")
    countryId = request.form.get("countryId","")
    try:
        if countryId:
            filters &=Q(countryId=countryId)
        states_queryset =(
                States.objects(filters)
                .only("id", "stateName")
                .order_by("stateName")
            )
        if states_queryset:
            for each_state in states_queryset:
                # doc = {
                # 	"id": each_state.id,
                # 	"stateName": each_state.stateName
                # }
                doc = each_state.to_mongo().to_dict()
                doc['id'] = str(doc.pop('_id'))
                states_list.append(doc)

        data_status.update({
            "responseStatus":1,
            "result":states_list
        })
        return data_status

    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["responseStatus"] = "Unable to fetch the States List!"
        return data_status

@regions.route("/get_cities_list", methods=["POST","GET"])
def get_cities_list():
    data_status = {"responseStatus":0,"result":""}
    if not session.get("adminId"):
        return redirect("admin_login")
    cities_list = []
    filters = Q(status__in=[0, 1])
    adminId = session.get("adminId")
    stateId = request.form.get("stateId", "")
    try:
        if stateId:
            filters &= Q(stateId=stateId)
        cities_queryset =(
                Cities.objects(filters)
                .only("id", "cityName")
                .order_by("cityName")
            )
        if cities_queryset:
            for each_city in cities_queryset:
                doc = each_city.to_mongo().to_dict()
                doc['id'] = str(doc.pop('_id'))
                cities_list.append(doc)

        data_status.update({
            "responseStatus":1,
            "result":cities_list
        })
        return data_status

    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["responseStatus"] = "Unable to fetch the Cities List!"
        return data_status

@regions.route("/get_blocks_list", methods=["POST","GET"])
def get_blocks_list():
    data_status = {"responseStatus":0,"result":""}
    if not session.get("adminId"):
        return redirect("admin_login")
    blocks_list = []
    filters = Q(status__in=[0, 1])
    adminId = session.get("adminId")
    cityId = request.form.get("cityId","")
    try:
        if cityId:
            filters &= Q(cityId=cityId)
            blocks_queryset =(
                    BlocksPos.objects(filters)
                    .only("id", "name")
                    .order_by("name")
                )
            if blocks_queryset:
                for each_block in blocks_queryset:
                    doc = each_block.to_mongo().to_dict()
                    doc['id'] = str(doc.pop('_id'))
                    blocks_list.append(doc)

        data_status.update({
            "responseStatus":1,
            "result":blocks_list
        })
        return data_status

    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["responseStatus"] = "Unable to fetch the blocks/PO List!"
        return data_status

@regions.route("/get_pincodes_list", methods=["POST","GET"])
def get_pincodes_list():
    data_status = {"responseStatus":0,"result":""}
    if not session.get("adminId"):
        return redirect("admin_login")
    pincodes_list = []
    filters = Q(status__in=[0, 1])
    adminId = session.get("adminId")
    try:
        pincodes_queryset =(
                Pincodes.objects(filters)
                .only("id", "pincode")
                .order_by("-id")
            )
        if pincodes_queryset:
            for each_pincode in pincodes_queryset:
                doc = each_pincode.to_mongo().to_dict()
                doc['id'] = str(doc.pop('pincode'))
                pincodes_list.append(doc)

        data_status.update({
            "responseStatus":1,
            "result":pincodes_list
        })
        return data_status

    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["responseStatus"] = "Unable to fetch the Cities List!"
        return data_status