diff --git a/.gitignore b/.gitignore index 5a326d5b..958f9b06 100644 --- a/.gitignore +++ b/.gitignore @@ -17,6 +17,9 @@ instance/uploads cover .coveralls.yml +# Ignore new frontend build artifacts +/frontend/node_modules + # Ignore bento tool run paths (this line added by `bento init`) .bento/ dump.rdb diff --git a/INSTALLATION.md b/INSTALLATION.md index 0822a15f..445465f6 100644 --- a/INSTALLATION.md +++ b/INSTALLATION.md @@ -24,7 +24,7 @@ To lookup individual representatives, you need: To test Twilio functionality in development, you will need your server to have a web-routable address. -* Twilio provides [ngrok](https://ngrok.com) to do this for free. When using the debug server you can use `flask run --host=SERVERID.ngrok.com` to set SERVER_NAME and STORE_DOMAIN +* Twilio provides [ngrok](https://ngrok.com) to do this for free. When using the debug server you can use `USE_NGROK=TRUE; python manage.py runserver` * To test text-to-speech playback in the browser, you will need to create a [TwiML app](https://www.twilio.com/user/account/apps) with the Voice request URL http://YOUR_HOSTNAME/api/twilio/text-to-speech. Place the resulting application SID in your environment as TWILIO_PLAYBACK_APP For production, you will also need to set: @@ -66,7 +66,7 @@ To install locally and run in debug mode use: export FLASK_APP=manager.py; FLASK_ENV=development; FLASK_DEBUG=1 # create the database - flask migrate up + python3 manage.py migrate # compile assets npm install -g bower @@ -74,7 +74,7 @@ To install locally and run in debug mode use: flask assets build # create an admin user - flask createadminuser + python3 manage.py createadminuser # if testing twilio, run in another tab ngrok http 5000 @@ -83,10 +83,8 @@ To install locally and run in debug mode use: export SERVER_NAME={{subdomain}}.ngrok.io flask run --host=0.0.0.0 - # if testing scheduled calls, run broker, scheduler and workers in new tabs - redis-server - flask rq scheduler - flask rq worker + # if testing scheduled calls, run the Django scheduler loop in a new tab + python3 manage.py runjobs When the dev server is running, the front-end will be accessible at [http://localhost:5000/](http://localhost:5000/), and proxied to external routes at [http://ngrok.com](http://ngrok.com). @@ -105,13 +103,13 @@ To run in production, with compiled assets: iptables -A INPUT -p tcp --dport 80 -j ACCEPT # initialize the database - flask migrate up + python3 manage.py migrate # create an admin user (with optional --username, --password, --email) - flask createadminuser + python3 manage.py createadminuser # prime cache with political data - flask loadpoliticaldata + python3 manage.py loadpoliticaldata # if you are running a reverse proxy, you can start the application with foreman start foreman start @@ -119,9 +117,8 @@ To run in production, with compiled assets: # or point your WSGI server to `call_server.wsgi:application` # to load the application directly - # if you wish to enable recurring outbound calls, you need to run the scheduler and at least one worker - flask rq scheduler - flask rq worker + # if you wish to enable recurring outbound calls, run the Django scheduler loop + python3 manage.py runjobs Make sure your webserver can serve audio files out of `APPLICATION_ROOT/instance/uploads`. Or if you are using Amazon S3, ensure your buckets are configured for public access. diff --git a/README.md b/README.md index d41b3ccf..54a7a9ea 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,20 @@ Call Power Connecting people to power through their phones. +Migration status +---------------- + +This repository now contains a side-by-side Django + React migration in addition +to the legacy Flask + Backbone application. + +- Legacy app: `call_server/` +- New Django app: `django_app/` +- New React admin UI: `frontend/` + +The new stack currently ports the admin shell foundation, dashboard summary API, +campaign editing APIs, a Django political-data layer, and an initial Twilio +call-flow foundation while reusing the existing database tables. + The admin interface lets activists: * Create and edit campaigns @@ -52,6 +66,8 @@ This application should be easy to host on Heroku, with Docker, or directly on a Read detailed instrustions at [INSTALLATION.md](INSTALLATION.md) +For the Django + React migration, see [django_app/README.md](django_app/README.md). + Testing ------- `python tests/run.py` diff --git a/django_app/README.md b/django_app/README.md new file mode 100644 index 00000000..bcec996f --- /dev/null +++ b/django_app/README.md @@ -0,0 +1,91 @@ +# Django + React migration + +This directory contains the new application stack for Call Power. It is designed +to run side-by-side with the legacy Flask app while features are ported over in +small slices. + +## What is migrated in this slice + +- Django project scaffold under `django_app/config` +- Legacy table mappings for campaigns, calls, sessions, scheduled calls, users, targets, CRM sync records, and blocklist records +- Django-managed scheduler metadata for recurring outbound calls and CRM sync timing +- JSON API endpoints for dashboard summary, campaign list/detail, campaign create/update, campaign copy, phone number lookup, and target lookup +- React admin shell in `frontend/` powered by Vite with editable campaign fields, phone-number assignment, target assignment, embed configuration, and CRM sync configuration +- Public Django pages for `/`, `/campaign//`, legacy `/create` aliases, and campaign embed endpoints +- Twilio call-flow foundation under `callpower/apps/calls/` for outbound call creation, inbound connection entrypoints, TwiML call chaining, and status callbacks backed by the legacy tables +- Twilio schedule prompt and recurring-call subscription flow backed by the Django-managed scheduler +- Django management commands for legacy operational tasks, including scheduler backfill and job execution +- Django CRM sync execution with `sync_call` tracking and scheduler-driven sync runs +- Django political-data providers under `callpower/apps/political_data/` for country data loading, cache-backed lookup, target hydration, and location-based target resolution used by the new Twilio flow + +## Current migration boundary + +The Django stack now covers the main webhook backbone and the political-data +lookup layer, but it is still not a perfect feature match with Flask. + +- US custom-target and US location-based targeting are now the strongest paths in the new stack +- Canada support still depends on the optional `represent` Python package being available +- Legacy third-party embed snippets can now point at the Django-served `/api/campaign//embed.js` and iframe endpoints +- CRM sync now runs from Django for the legacy `rogue`, `mobilecommons`, and optional `actionkit` integrations +- `actionkit` still depends on the optional `python-actionkit` package being installed in the runtime + +## Development + +1. Install Python dependencies from `requirements/common.txt` +2. Install frontend dependencies in `frontend/` +3. Start Django: + +```bash +python3 manage.py runserver +``` + +4. Start React: + +```bash +cd frontend +npm install +npm run dev +``` + +The Django admin shell is served at `/admin/`, and in development it loads the +React app from the Vite dev server. + +The public site root is served at `/`, public campaign pages at `/campaign//`, +and legacy call-congress compatibility aliases remain available at `/create`, +`/incoming_call`, and `/call_complete_status`. + +## Scheduled jobs + +Recurring jobs are now managed by Django instead of Flask RQ. + +- Backfill scheduler rows from existing `schedule_call` and `sync_campaign` records: + +```bash +python3 manage.py syncscheduledjobs +``` + +- Run the scheduler loop: + +```bash +python3 manage.py runjobs +``` + +- Run a single scheduler tick: + +```bash +python3 manage.py runjobs --once +``` + +- Run CRM sync immediately for one campaign or all configured campaigns: + +```bash +python3 manage.py crmsync 123 +python3 manage.py crmsync all +``` + +## Database compatibility + +The Django models in this slice use `managed = False` so Django can read from +the existing schema without trying to recreate or alter the legacy tables. As +more of the application is migrated, we can introduce Django-native migrations +for new tables and selectively take ownership of old ones. diff --git a/django_app/callpower/__init__.py b/django_app/callpower/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/django_app/callpower/apps/__init__.py b/django_app/callpower/apps/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/django_app/callpower/apps/api/__init__.py b/django_app/callpower/apps/api/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/django_app/callpower/apps/api/apps.py b/django_app/callpower/apps/api/apps.py new file mode 100644 index 00000000..858cf88f --- /dev/null +++ b/django_app/callpower/apps/api/apps.py @@ -0,0 +1,6 @@ +from django.apps import AppConfig + + +class ApiConfig(AppConfig): + default_auto_field = "django.db.models.BigAutoField" + name = "callpower.apps.api" diff --git a/django_app/callpower/apps/api/serializers.py b/django_app/callpower/apps/api/serializers.py new file mode 100644 index 00000000..ae85822a --- /dev/null +++ b/django_app/callpower/apps/api/serializers.py @@ -0,0 +1,347 @@ +from django.db import transaction +from rest_framework import serializers + +from callpower.apps.core.models import ( + AudioRecording, + Campaign, + CampaignAudioRecording, + CampaignPhoneNumber, + CampaignTarget, + ScheduleCall, + SyncCampaign, + Target, + TwilioPhoneNumber, +) + + +class CampaignSummarySerializer(serializers.ModelSerializer): + completed_calls = serializers.IntegerField(source="completed_calls_count", read_only=True) + total_sessions = serializers.IntegerField(source="total_sessions_count", read_only=True) + + class Meta: + model = Campaign + fields = [ + "id", + "name", + "country_code", + "campaign_type", + "campaign_state", + "campaign_subtype", + "status_code", + "allow_call_in", + "prompt_schedule", + "completed_calls", + "total_sessions", + ] + + +class TwilioPhoneNumberSerializer(serializers.ModelSerializer): + class Meta: + model = TwilioPhoneNumber + fields = ["id", "number", "call_in_allowed", "call_in_campaign_id"] + + +class TargetSerializer(serializers.ModelSerializer): + class Meta: + model = Target + fields = ["id", "key", "title", "name", "district", "number", "location"] + + +class CampaignAudioRecordingSerializer(serializers.ModelSerializer): + file_url = serializers.SerializerMethodField() + selected = serializers.SerializerMethodField() + + class Meta: + model = AudioRecording + fields = [ + "id", + "key", + "version", + "description", + "text_to_speech", + "hidden", + "file_url", + "selected", + ] + + def get_file_url(self, obj): + return obj.file_url() + + def get_selected(self, obj): + campaign = self.context.get("campaign") + if not campaign: + return False + return CampaignAudioRecording.objects.filter( + campaign=campaign, + recording=obj, + selected=True, + ).exists() + + +class CampaignDetailSerializer(serializers.ModelSerializer): + phone_number_ids = serializers.ListField( + child=serializers.IntegerField(min_value=1), + write_only=True, + required=False, + ) + assigned_phone_numbers = serializers.SerializerMethodField() + target_ids = serializers.ListField( + child=serializers.IntegerField(min_value=1), + write_only=True, + required=False, + ) + assigned_targets = serializers.SerializerMethodField() + embed_type = serializers.CharField(write_only=True, required=False, allow_blank=True) + embed_script = serializers.CharField(write_only=True, required=False, allow_blank=True) + embed_form_sel = serializers.CharField(write_only=True, required=False, allow_blank=True) + embed_phone_sel = serializers.CharField(write_only=True, required=False, allow_blank=True) + embed_location_sel = serializers.CharField(write_only=True, required=False, allow_blank=True) + embed_custom_css = serializers.CharField(write_only=True, required=False, allow_blank=True) + embed_custom_js = serializers.CharField(write_only=True, required=False, allow_blank=True) + embed_custom_onload = serializers.CharField(write_only=True, required=False, allow_blank=True) + embed_script_display = serializers.CharField(write_only=True, required=False, allow_blank=True) + embed_phone_display = serializers.CharField(write_only=True, required=False, allow_blank=True) + embed_redirect = serializers.CharField(write_only=True, required=False, allow_blank=True) + crm_sync = serializers.BooleanField(write_only=True, required=False, default=False) + crm_id = serializers.CharField(write_only=True, required=False, allow_blank=True) + crm_key = serializers.CharField(write_only=True, required=False, allow_blank=True) + sync_schedule = serializers.CharField(write_only=True, required=False, allow_blank=True) + + class Meta: + model = Campaign + fields = [ + "id", + "name", + "country_code", + "campaign_type", + "campaign_state", + "campaign_subtype", + "campaign_language", + "segment_by", + "locate_by", + "include_special", + "target_ordering", + "target_shuffle_chamber", + "target_offices", + "call_maximum", + "allow_call_in", + "allow_intl_calls", + "prompt_schedule", + "status_code", + "embed", + "assigned_phone_numbers", + "phone_number_ids", + "assigned_targets", + "target_ids", + "embed_type", + "embed_script", + "embed_form_sel", + "embed_phone_sel", + "embed_location_sel", + "embed_custom_css", + "embed_custom_js", + "embed_custom_onload", + "embed_script_display", + "embed_phone_display", + "embed_redirect", + "crm_sync", + "crm_id", + "crm_key", + "sync_schedule", + ] + read_only_fields = ["id", "assigned_phone_numbers", "assigned_targets"] + + def get_assigned_phone_numbers(self, obj): + links = obj.campaign_phone_links.select_related("phone").all() + return TwilioPhoneNumberSerializer([link.phone for link in links], many=True).data + + def get_assigned_targets(self, obj): + links = obj.campaign_target_links.select_related("target").order_by("order", "id").all() + return TargetSerializer([link.target for link in links], many=True).data + + def to_representation(self, instance): + data = super().to_representation(instance) + embed = instance.embed or {} + data.update( + { + "embed_type": embed.get("type", ""), + "embed_script": embed.get("script", ""), + "embed_form_sel": embed.get("form_sel", ""), + "embed_phone_sel": embed.get("phone_sel", ""), + "embed_location_sel": embed.get("location_sel", ""), + "embed_custom_css": embed.get("custom_css", ""), + "embed_custom_js": embed.get("custom_js", ""), + "embed_custom_onload": embed.get("custom_onload", ""), + "embed_script_display": embed.get("script_display", ""), + "embed_phone_display": embed.get("phone_display", ""), + "embed_redirect": embed.get("redirect", ""), + "crm_sync": hasattr(instance, "sync_campaign") and instance.sync_campaign is not None, + "crm_id": getattr(getattr(instance, "sync_campaign", None), "crm_id", "") or "", + "crm_key": getattr(getattr(instance, "sync_campaign", None), "crm_key", "") or "", + "sync_schedule": getattr(getattr(instance, "sync_campaign", None), "schedule", "") or "", + } + ) + return data + + def _sync_phone_numbers(self, campaign, phone_number_ids): + if phone_number_ids is None: + return + + existing_ids = set( + campaign.campaign_phone_links.values_list("phone_id", flat=True) + ) + desired_ids = set(phone_number_ids) + + for stale_id in existing_ids - desired_ids: + CampaignPhoneNumber.objects.filter( + campaign=campaign, + phone_id=stale_id, + ).delete() + + for phone_id in desired_ids - existing_ids: + CampaignPhoneNumber.objects.create(campaign=campaign, phone_id=phone_id) + + def _sync_targets(self, campaign, target_ids): + if target_ids is None: + return + + existing_ids = list( + campaign.campaign_target_links.order_by("order", "id").values_list("target_id", flat=True) + ) + desired_ids = list(dict.fromkeys(target_ids)) + + CampaignTarget.objects.filter(campaign=campaign).delete() + for order, target_id in enumerate(desired_ids): + CampaignTarget.objects.create( + campaign=campaign, + target_id=target_id, + order=order, + ) + + def _sync_embed_settings(self, validated_data): + embed_type = validated_data.pop("embed_type", None) + embed_script = validated_data.pop("embed_script", None) + embed_form_sel = validated_data.pop("embed_form_sel", None) + embed_phone_sel = validated_data.pop("embed_phone_sel", None) + embed_location_sel = validated_data.pop("embed_location_sel", None) + embed_custom_css = validated_data.pop("embed_custom_css", None) + embed_custom_js = validated_data.pop("embed_custom_js", None) + embed_custom_onload = validated_data.pop("embed_custom_onload", None) + embed_script_display = validated_data.pop("embed_script_display", None) + embed_phone_display = validated_data.pop("embed_phone_display", None) + embed_redirect = validated_data.pop("embed_redirect", None) + + touched = any( + value is not None + for value in [ + embed_type, + embed_script, + embed_form_sel, + embed_phone_sel, + embed_location_sel, + embed_custom_css, + embed_custom_js, + embed_custom_onload, + embed_script_display, + embed_phone_display, + embed_redirect, + ] + ) + if not touched: + return validated_data + + embed = {} + if embed_type == "custom": + embed = { + "type": embed_type, + "form_sel": embed_form_sel or "", + "phone_sel": embed_phone_sel or "", + "location_sel": embed_location_sel or "", + "custom_css": embed_custom_css or "", + "custom_js": embed_custom_js or "", + "custom_onload": embed_custom_onload or "", + "script_display": embed_script_display or "", + "phone_display": embed_phone_display or "", + "redirect": embed_redirect or "", + } + elif embed_type == "iframe": + embed = { + "type": embed_type, + "custom_css": embed_custom_css or "", + "script_display": "replace", + } + + if embed_script is not None: + embed["script"] = embed_script + + validated_data["embed"] = embed + return validated_data + + def _sync_crm_settings(self, campaign, crm_sync, crm_id, crm_key, sync_schedule): + if crm_sync: + sync_campaign, _created = SyncCampaign.objects.get_or_create( + campaign=campaign, + defaults={"schedule": sync_schedule or "hourly"}, + ) + sync_campaign.crm_id = crm_id or "" + sync_campaign.crm_key = crm_key or "" + if sync_schedule: + sync_campaign.schedule = sync_schedule + sync_campaign.save() + if sync_campaign.has_schedule(): + sync_campaign.start(sync_campaign.schedule) + else: + sync_campaign = SyncCampaign.objects.filter(campaign=campaign).first() + if sync_campaign: + sync_campaign.crm_id = "" + sync_campaign.crm_key = "" + if sync_schedule: + sync_campaign.schedule = sync_schedule + sync_campaign.save() + sync_campaign.stop() + + def _sync_campaign_status_side_effects(self, campaign): + if campaign.status_code == 2: + for schedule_call in ScheduleCall.objects.filter(campaign=campaign, subscribed=True).order_by("id"): + schedule_call.start_job() + return + + for schedule_call in ScheduleCall.objects.filter(campaign=campaign, subscribed=True).order_by("id"): + schedule_call.stop_job() + + @transaction.atomic + def create(self, validated_data): + phone_number_ids = validated_data.pop("phone_number_ids", []) + target_ids = validated_data.pop("target_ids", []) + crm_sync = validated_data.pop("crm_sync", False) + crm_id = validated_data.pop("crm_id", "") + crm_key = validated_data.pop("crm_key", "") + sync_schedule = validated_data.pop("sync_schedule", "") + validated_data = self._sync_embed_settings(validated_data) + campaign = Campaign.objects.create(**validated_data) + self._sync_phone_numbers(campaign, phone_number_ids) + self._sync_targets(campaign, target_ids) + self._sync_crm_settings(campaign, crm_sync, crm_id, crm_key, sync_schedule) + self._sync_campaign_status_side_effects(campaign) + return campaign + + @transaction.atomic + def update(self, instance, validated_data): + phone_number_ids = validated_data.pop("phone_number_ids", None) + target_ids = validated_data.pop("target_ids", None) + crm_sync = validated_data.pop("crm_sync", None) + crm_id = validated_data.pop("crm_id", "") + crm_key = validated_data.pop("crm_key", "") + sync_schedule = validated_data.pop("sync_schedule", "") + validated_data = self._sync_embed_settings(validated_data) + + for attr, value in validated_data.items(): + setattr(instance, attr, value) + instance.save() + + self._sync_phone_numbers(instance, phone_number_ids) + self._sync_targets(instance, target_ids) + if crm_sync is not None: + self._sync_crm_settings(instance, crm_sync, crm_id, crm_key, sync_schedule) + self._sync_campaign_status_side_effects(instance) + return instance diff --git a/django_app/callpower/apps/api/urls.py b/django_app/callpower/apps/api/urls.py new file mode 100644 index 00000000..d57b3159 --- /dev/null +++ b/django_app/callpower/apps/api/urls.py @@ -0,0 +1,34 @@ +from django.urls import path + +from callpower.apps.api.views import ( + CampaignAudioHideApi, + CampaignAudioListApi, + CampaignAudioSelectApi, + CampaignAudioShowApi, + CampaignAudioUploadApi, + CampaignCopyApi, + CampaignDetailApi, + CampaignLaunchApi, + CampaignListApi, + CampaignTestCallApi, + DashboardSummaryApi, + PhoneNumberListApi, + TargetListApi, +) + + +urlpatterns = [ + path("dashboard/summary/", DashboardSummaryApi.as_view(), name="dashboard-summary"), + path("campaigns/", CampaignListApi.as_view(), name="campaign-list"), + path("campaigns//", CampaignDetailApi.as_view(), name="campaign-detail"), + path("campaigns//copy/", CampaignCopyApi.as_view(), name="campaign-copy"), + path("campaigns//audio/", CampaignAudioListApi.as_view(), name="campaign-audio-list"), + path("campaigns//audio/upload/", CampaignAudioUploadApi.as_view(), name="campaign-audio-upload"), + path("campaigns//audio//select/", CampaignAudioSelectApi.as_view(), name="campaign-audio-select"), + path("campaigns//audio//hide/", CampaignAudioHideApi.as_view(), name="campaign-audio-hide"), + path("campaigns//audio//show/", CampaignAudioShowApi.as_view(), name="campaign-audio-show"), + path("campaigns//launch/", CampaignLaunchApi.as_view(), name="campaign-launch"), + path("campaigns//test-call/", CampaignTestCallApi.as_view(), name="campaign-test-call"), + path("phone-numbers/", PhoneNumberListApi.as_view(), name="phone-number-list"), + path("targets/", TargetListApi.as_view(), name="target-list"), +] diff --git a/django_app/callpower/apps/api/views.py b/django_app/callpower/apps/api/views.py new file mode 100644 index 00000000..b7ee7638 --- /dev/null +++ b/django_app/callpower/apps/api/views.py @@ -0,0 +1,438 @@ +import os +import json + +from django.conf import settings +from django.core.files.storage import default_storage +from django.test import RequestFactory +from django.db import transaction +from django.db.models import Count, Q +from django.shortcuts import render +from django.utils import timezone +from django.views.generic import TemplateView +from rest_framework.parsers import FormParser, MultiPartParser +from rest_framework import status +from rest_framework.exceptions import NotAuthenticated +from rest_framework.response import Response +from rest_framework.views import APIView +from django.utils.decorators import method_decorator +from django.views.decorators.csrf import csrf_exempt + +from callpower.apps.api.serializers import ( + CampaignAudioRecordingSerializer, + CampaignDetailSerializer, + CampaignSummarySerializer, + TargetSerializer, + TwilioPhoneNumberSerializer, +) +from callpower.apps.calls.views import create as create_call_view +from callpower.apps.core.models import ( + AudioRecording, + Blocklist, + Call, + Campaign, + CampaignAudioRecording, + CampaignPhoneNumber, + CampaignTarget, + LegacyUser, + ScheduleCall, + Target, + TwilioPhoneNumber, +) + + +class AdminAppView(TemplateView): + template_name = "admin_app.html" + + def get(self, request, *args, **kwargs): + return render( + request, + self.template_name, + { + "debug": settings.DEBUG, + "react_dev_server_url": settings.REACT_DEV_SERVER_URL.rstrip("/"), + }, + ) + + +@method_decorator(csrf_exempt, name="dispatch") +class AuthenticatedAPIView(APIView): + def initial(self, request, *args, **kwargs): + super().initial(request, *args, **kwargs) + if not request.user.is_authenticated or not request.session.get("legacy_user_id"): + raise NotAuthenticated("Authentication required") + + +class DashboardSummaryApi(AuthenticatedAPIView): + def get(self, request): + now = timezone.now() + month_start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0) + + payload = { + "campaigns": Campaign.objects.count(), + "completed_calls_this_month": Call.objects.filter( + status="completed", + timestamp__gte=month_start, + ).count(), + "scheduled_calls": ScheduleCall.objects.filter(subscribed=True).count(), + "active_blocks": sum(1 for block in Blocklist.objects.all() if block.is_active()), + "users": LegacyUser.objects.count(), + } + return Response(payload) + + +class CampaignListApi(AuthenticatedAPIView): + def get(self, request): + queryset = Campaign.with_dashboard_counts() + + status_code = request.query_params.get("status_code") + if status_code not in (None, ""): + queryset = queryset.filter(status_code=status_code) + + search = request.query_params.get("q") + if search: + queryset = queryset.filter(name__icontains=search) + + queryset = queryset.annotate( + active_scheduled_calls=Count( + "scheduled_calls", + filter=Q(scheduled_calls__subscribed=True), + distinct=True, + ) + )[:50] + + data = CampaignSummarySerializer(queryset, many=True).data + for item, campaign in zip(data, queryset): + item["active_scheduled_calls"] = getattr(campaign, "active_scheduled_calls", 0) + return Response({"count": len(data), "results": data}) + + def post(self, request): + serializer = CampaignDetailSerializer(data=request.data) + serializer.is_valid(raise_exception=True) + campaign = serializer.save() + return Response( + CampaignDetailSerializer(campaign).data, + status=status.HTTP_201_CREATED, + ) + + +class CampaignDetailApi(AuthenticatedAPIView): + def get_object(self, campaign_id): + return Campaign.objects.get(pk=campaign_id) + + def get(self, request, campaign_id): + campaign = self.get_object(campaign_id) + return Response(CampaignDetailSerializer(campaign).data) + + def patch(self, request, campaign_id): + campaign = self.get_object(campaign_id) + serializer = CampaignDetailSerializer( + campaign, + data=request.data, + partial=True, + ) + serializer.is_valid(raise_exception=True) + campaign = serializer.save() + return Response(CampaignDetailSerializer(campaign).data) + + +class CampaignCopyApi(AuthenticatedAPIView): + @transaction.atomic + def post(self, request, campaign_id): + source = Campaign.objects.get(pk=campaign_id) + copy_campaign = Campaign.objects.create( + name=f"{source.name} (copy)", + country_code=source.country_code, + campaign_type=source.campaign_type, + campaign_state=source.campaign_state, + campaign_subtype=source.campaign_subtype, + campaign_language=source.campaign_language, + segment_by=source.segment_by, + locate_by=source.locate_by, + include_special=source.include_special, + target_ordering=source.target_ordering, + target_shuffle_chamber=source.target_shuffle_chamber, + target_offices=source.target_offices, + call_maximum=source.call_maximum, + allow_call_in=source.allow_call_in, + allow_intl_calls=source.allow_intl_calls, + prompt_schedule=source.prompt_schedule, + status_code=source.status_code, + embed=source.embed, + ) + + for link in source.campaign_phone_links.all(): + CampaignPhoneNumber.objects.create( + campaign=copy_campaign, + phone_id=link.phone_id, + ) + + for link in source.campaign_target_links.order_by("order", "id").all(): + CampaignTarget.objects.create( + campaign=copy_campaign, + target_id=link.target_id, + order=link.order, + ) + + return Response( + CampaignDetailSerializer(copy_campaign).data, + status=status.HTTP_201_CREATED, + ) + + +class PhoneNumberListApi(AuthenticatedAPIView): + def get(self, request): + queryset = TwilioPhoneNumber.objects.order_by("id") + return Response( + { + "count": queryset.count(), + "results": TwilioPhoneNumberSerializer(queryset, many=True).data, + } + ) + + +class TargetListApi(AuthenticatedAPIView): + def get(self, request): + queryset = Target.objects.order_by("name", "id") + search = request.query_params.get("q") + if search: + queryset = queryset.filter( + Q(name__icontains=search) + | Q(title__icontains=search) + | Q(location__icontains=search) + | Q(key__icontains=search) + ) + queryset = queryset[:100] + return Response( + { + "count": len(queryset), + "results": TargetSerializer(queryset, many=True).data, + } + ) + + +class CampaignAudioListApi(AuthenticatedAPIView): + def get(self, request, campaign_id): + campaign = Campaign.objects.get(pk=campaign_id) + queryset = ( + AudioRecording.objects.filter(campaign_audio_recordings__campaign=campaign) + .distinct() + .order_by("key", "-version", "-id") + ) + key = request.query_params.get("key") + if key: + queryset = queryset.filter(key=key) + return Response( + { + "count": queryset.count(), + "results": CampaignAudioRecordingSerializer( + queryset, + many=True, + context={"campaign": campaign}, + ).data, + } + ) + + +class CampaignAudioUploadApi(AuthenticatedAPIView): + parser_classes = [MultiPartParser, FormParser] + + def _validate_upload(self, uploaded_file): + if not uploaded_file: + return None + + allowed_content_types = { + "audio/wav", + "audio/x-wav", + "audio/mpeg", + "audio/mp3", + } + extension = os.path.splitext(uploaded_file.name)[1].lower() + if uploaded_file.content_type not in allowed_content_types and extension not in {".wav", ".mp3"}: + raise ValueError(f"File type must be mp3 or wav, got {uploaded_file.content_type or extension}.") + return extension.lstrip(".") or "mp3" + + @transaction.atomic + def post(self, request, campaign_id): + campaign = Campaign.objects.get(pk=campaign_id) + message_key = (request.data.get("key") or "").strip() + description = (request.data.get("description") or "").strip() + text_to_speech = (request.data.get("text_to_speech") or "").strip() + uploaded_file = request.FILES.get("file_storage") + + if not message_key: + return Response({"success": False, "errors": {"key": ["This field is required."]}}, status=400) + if not uploaded_file and not text_to_speech: + return Response( + {"success": False, "errors": {"file_storage": ["Upload a file or provide text_to_speech."]}}, + status=400, + ) + + try: + extension = self._validate_upload(uploaded_file) + except ValueError as exc: + return Response({"success": False, "errors": {"file_storage": [str(exc)]}}, status=400) + + last_version = ( + AudioRecording.objects.filter(key=message_key).order_by("-version").values_list("version", flat=True).first() + ) + version = int(last_version or 0) + 1 + + stored_name = "" + if uploaded_file: + stored_name = default_storage.save( + f"audio/campaign_{campaign.id}_{message_key}_{version}.{extension}", + uploaded_file, + ) + + recording = AudioRecording.objects.create( + key=message_key, + file_storage=stored_name or "", + text_to_speech="" if uploaded_file else text_to_speech, + version=version, + description=description, + hidden=False, + ) + + CampaignAudioRecording.objects.filter( + campaign=campaign, + recording__key=message_key, + ).update(selected=False) + + CampaignAudioRecording.objects.update_or_create( + campaign=campaign, + recording=recording, + defaults={"selected": True}, + ) + + return Response( + { + "success": True, + "message": "Audio recording uploaded", + "key": message_key, + "version": version, + "recording": CampaignAudioRecordingSerializer( + recording, + context={"campaign": campaign}, + ).data, + }, + status=status.HTTP_201_CREATED, + ) + + +class CampaignAudioSelectApi(AuthenticatedAPIView): + @transaction.atomic + def post(self, request, campaign_id, recording_id): + campaign = Campaign.objects.get(pk=campaign_id) + recording = AudioRecording.objects.get(pk=recording_id) + + CampaignAudioRecording.objects.filter( + campaign=campaign, + recording__key=recording.key, + ).update(selected=False) + + CampaignAudioRecording.objects.update_or_create( + campaign=campaign, + recording=recording, + defaults={"selected": True}, + ) + + return Response( + { + "success": True, + "message": "Audio recording selected", + "key": recording.key, + "version": recording.version, + "recording": CampaignAudioRecordingSerializer( + recording, + context={"campaign": campaign}, + ).data, + } + ) + + +class CampaignAudioHideApi(AuthenticatedAPIView): + @transaction.atomic + def post(self, request, campaign_id, recording_id): + campaign = Campaign.objects.get(pk=campaign_id) + recording = AudioRecording.objects.get(pk=recording_id) + recording.hidden = True + recording.save(update_fields=["hidden"]) + CampaignAudioRecording.objects.filter(campaign=campaign, recording=recording).update(selected=False) + return Response( + { + "success": True, + "message": "Audio recording hidden", + "key": recording.key, + "version": recording.version, + "recording": CampaignAudioRecordingSerializer( + recording, + context={"campaign": campaign}, + ).data, + } + ) + + +class CampaignAudioShowApi(AuthenticatedAPIView): + def post(self, request, campaign_id, recording_id): + campaign = Campaign.objects.get(pk=campaign_id) + recording = AudioRecording.objects.get(pk=recording_id) + recording.hidden = False + recording.save(update_fields=["hidden"]) + return Response( + { + "success": True, + "message": "Audio recording visible", + "key": recording.key, + "version": recording.version, + "recording": CampaignAudioRecordingSerializer( + recording, + context={"campaign": campaign}, + ).data, + } + ) + + +class CampaignLaunchApi(AuthenticatedAPIView): + def post(self, request, campaign_id): + campaign = Campaign.objects.get(pk=campaign_id) + campaign.status_code = 2 + campaign.save(update_fields=["status_code"]) + return Response( + { + "success": True, + "message": "Campaign launched", + "campaign": CampaignDetailSerializer(campaign).data, + } + ) + + +class CampaignTestCallApi(AuthenticatedAPIView): + def post(self, request, campaign_id): + campaign = Campaign.objects.get(pk=campaign_id) + payload = request.data + phone = (payload.get("userPhone") or "").strip() + location = (payload.get("userLocation") or "").strip() + country = (payload.get("userCountry") or campaign.country_code or "US").strip() + record = payload.get("record") + + if not phone: + return Response( + {"success": False, "error": "userPhone is required"}, + status=status.HTTP_400_BAD_REQUEST, + ) + + factory = RequestFactory() + internal_request = factory.post( + "/call/create", + data={ + "campaignId": str(campaign.id), + "userPhone": phone, + "userLocation": location, + "userCountry": country, + "record": record or "", + }, + ) + internal_request.META["REMOTE_ADDR"] = request.META.get("REMOTE_ADDR", "127.0.0.1") + response = create_call_view(internal_request) + payload = json.loads(response.content.decode("utf-8")) + return Response(payload, status=response.status_code) diff --git a/django_app/callpower/apps/auth/__init__.py b/django_app/callpower/apps/auth/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/django_app/callpower/apps/auth/apps.py b/django_app/callpower/apps/auth/apps.py new file mode 100644 index 00000000..34ba91f3 --- /dev/null +++ b/django_app/callpower/apps/auth/apps.py @@ -0,0 +1,7 @@ +from django.apps import AppConfig + + +class AuthConfig(AppConfig): + default_auto_field = "django.db.models.BigAutoField" + name = "callpower.apps.auth" + label = "callpower_auth" diff --git a/django_app/callpower/apps/auth/forms.py b/django_app/callpower/apps/auth/forms.py new file mode 100644 index 00000000..5d221894 --- /dev/null +++ b/django_app/callpower/apps/auth/forms.py @@ -0,0 +1,198 @@ +from django import forms + +from callpower.apps.core.models import LegacyUser, USER_ROLE, USER_STATUS + + +PASSWORD_LEN_MIN = 6 +PASSWORD_LEN_MAX = 64 +USERNAME_LEN_MIN = 4 +USERNAME_LEN_MAX = 25 + + +class LoginForm(forms.Form): + next = forms.CharField(widget=forms.HiddenInput(), required=False) + login = forms.CharField(label="Username or email") + password = forms.CharField( + label="Password", + min_length=PASSWORD_LEN_MIN, + max_length=PASSWORD_LEN_MAX, + widget=forms.PasswordInput, + ) + remember = forms.BooleanField(label="Remember me", required=False) + + +class ReauthForm(forms.Form): + next = forms.CharField(widget=forms.HiddenInput(), required=False) + password = forms.CharField( + label="Password", + min_length=PASSWORD_LEN_MIN, + max_length=PASSWORD_LEN_MAX, + widget=forms.PasswordInput, + ) + + +class CreateUserForm(forms.Form): + next = forms.CharField(widget=forms.HiddenInput(), required=False) + email = forms.EmailField(label="Email") + name = forms.CharField( + label="Username", + min_length=USERNAME_LEN_MIN, + max_length=USERNAME_LEN_MAX, + ) + phone = forms.CharField(label="Phone Number", required=False, max_length=64) + password = forms.CharField( + label="Password", + min_length=PASSWORD_LEN_MIN, + max_length=PASSWORD_LEN_MAX, + widget=forms.PasswordInput, + ) + password_confirm = forms.CharField(label="Password Confirm", widget=forms.PasswordInput) + + def __init__(self, *args, user=None, **kwargs): + self.user = user + super().__init__(*args, **kwargs) + + def clean(self): + cleaned_data = super().clean() + if cleaned_data.get("password") != cleaned_data.get("password_confirm"): + self.add_error("password_confirm", "Passwords don't match") + return cleaned_data + + def clean_name(self): + name = self.cleaned_data["name"].strip() + query = LegacyUser.objects.filter(name__iexact=name) + if self.user: + query = query.exclude(pk=self.user.pk) + if query.exists(): + raise forms.ValidationError("This username is already registered") + return name + + def clean_email(self): + email = self.cleaned_data["email"].strip().lower() + query = LegacyUser.objects.filter(email__iexact=email) + if self.user: + query = query.exclude(pk=self.user.pk) + if query.exists(): + raise forms.ValidationError("This email is already registered") + return email + + +class UserForm(forms.Form): + next = forms.CharField(widget=forms.HiddenInput(), required=False) + email = forms.EmailField(label="Email") + name = forms.CharField( + label="Username", + min_length=USERNAME_LEN_MIN, + max_length=USERNAME_LEN_MAX, + ) + phone = forms.CharField(label="Phone Number", required=False, max_length=64) + + def __init__(self, *args, user=None, **kwargs): + self.user = user + super().__init__(*args, **kwargs) + + def clean_name(self): + name = self.cleaned_data["name"].strip() + query = LegacyUser.objects.filter(name__iexact=name) + if self.user: + query = query.exclude(pk=self.user.pk) + if query.exists(): + raise forms.ValidationError("This username is already registered") + return name + + def clean_email(self): + email = self.cleaned_data["email"].strip().lower() + query = LegacyUser.objects.filter(email__iexact=email) + if self.user: + query = query.exclude(pk=self.user.pk) + if query.exists(): + raise forms.ValidationError("This email is already registered") + return email + + +class InviteUserForm(forms.Form): + name = forms.CharField( + label="Username", + min_length=USERNAME_LEN_MIN, + max_length=USERNAME_LEN_MAX, + ) + email = forms.EmailField(label="Email") + + def clean_name(self): + name = self.cleaned_data["name"].strip() + if LegacyUser.objects.filter(name__iexact=name).exists(): + raise forms.ValidationError("This username is already registered") + return name + + def clean_email(self): + email = self.cleaned_data["email"].strip().lower() + if LegacyUser.objects.filter(email__iexact=email).exists(): + raise forms.ValidationError("This email is already registered") + return email + + +class RecoverPasswordForm(forms.Form): + email = forms.EmailField(label="Email") + + +class ChangePasswordForm(forms.Form): + email = forms.CharField(widget=forms.HiddenInput(), required=False) + activation_key = forms.CharField(widget=forms.HiddenInput(), required=False) + password = forms.CharField( + label="Password", + min_length=PASSWORD_LEN_MIN, + max_length=PASSWORD_LEN_MAX, + widget=forms.PasswordInput, + ) + password_confirm = forms.CharField(label="Password Confirm", widget=forms.PasswordInput) + + def clean(self): + cleaned_data = super().clean() + if cleaned_data.get("password") != cleaned_data.get("password_confirm"): + self.add_error("password_confirm", "Passwords don't match") + return cleaned_data + + +class UserRoleForm(forms.Form): + next = forms.CharField(widget=forms.HiddenInput(), required=False) + role_code = forms.ChoiceField( + label="Role", + choices=[(str(value), label) for value, label in USER_ROLE.items()], + ) + status_code = forms.ChoiceField( + label="Status", + choices=[(str(value), label) for value, label in USER_STATUS.items()], + ) + + def clean_role_code(self): + return int(self.cleaned_data["role_code"]) + + def clean_status_code(self): + return int(self.cleaned_data["status_code"]) + + +class RemoveUserForm(forms.Form): + username = forms.CharField(widget=forms.HiddenInput) + confirm_username = forms.CharField(label="Confirm Username") + + def clean(self): + cleaned_data = super().clean() + if cleaned_data.get("username") != cleaned_data.get("confirm_username"): + self.add_error("confirm_username", "Usernames don't match") + return cleaned_data + + +def invitation_initial(user): + return { + "email": user.email, + "name": user.name, + "phone": user.phone or "", + } + + +def profile_initial(user): + return { + "email": user.email, + "name": user.name, + "phone": user.phone or "", + } diff --git a/django_app/callpower/apps/auth/urls.py b/django_app/callpower/apps/auth/urls.py new file mode 100644 index 00000000..cb17a66d --- /dev/null +++ b/django_app/callpower/apps/auth/urls.py @@ -0,0 +1,23 @@ +from django.urls import path + +from callpower.apps.auth import views + + +urlpatterns = [ + path("auth/login/", views.login_view, name="auth-login"), + path("auth/logout/", views.logout_view, name="auth-logout"), + path("auth/me/", views.me_view, name="auth-me"), + path("user/login/", views.login_page, name="user-login"), + path("user/reauth/", views.reauth_page, name="user-reauth"), + path("user/logout/", views.logout_page, name="user-logout"), + path("user/create_account", views.create_account_page, name="user-create-account"), + path("user/change_password", views.change_password_page, name="user-change-password"), + path("user/reset_password", views.reset_password_page, name="user-reset-password"), + path("user/profile", views.profile_page, name="user-profile"), + path("user//profile", views.profile_page, name="user-profile-id"), + path("user/invite", views.invite_page, name="user-invite"), + path("user//remove", views.remove_page, name="user-remove"), + path("user/lang/", views.language_view, name="user-language"), + path("admin/user", views.index_page, name="user-index"), + path("admin/user//role", views.role_page, name="user-role"), +] diff --git a/django_app/callpower/apps/auth/views.py b/django_app/callpower/apps/auth/views.py new file mode 100644 index 00000000..e365fdb2 --- /dev/null +++ b/django_app/callpower/apps/auth/views.py @@ -0,0 +1,480 @@ +import json +from datetime import timedelta +from uuid import uuid4 + +from django.conf import settings +from django.contrib import messages +from django.contrib.auth import authenticate, login, logout +from django.contrib.auth.models import User +from django.core.mail import send_mail +from django.http import JsonResponse +from django.shortcuts import get_object_or_404, redirect, render +from django.template.loader import render_to_string +from django.urls import reverse +from django.utils import timezone +from django.views.decorators.csrf import csrf_exempt +from django.views.decorators.http import require_GET, require_POST + +from callpower.apps.auth.forms import ( + ChangePasswordForm, + CreateUserForm, + InviteUserForm, + LoginForm, + RecoverPasswordForm, + ReauthForm, + RemoveUserForm, + UserForm, + UserRoleForm, + invitation_initial, + profile_initial, +) +from callpower.apps.core.models import LegacyUser, USER_ACTIVE, USER_ADMIN, USER_NEW + + +REAUTH_WINDOW = timedelta(minutes=15) + + +def _legacy_user_from_request(request): + legacy_user_id = request.session.get("legacy_user_id") + if not legacy_user_id: + return None + return LegacyUser.objects.filter(pk=legacy_user_id).first() + + +def _sync_django_user(legacy_user): + django_user = User.objects.filter(username=f"legacy-{legacy_user.id}").first() + if not django_user: + django_user = User(username=f"legacy-{legacy_user.id}") + django_user.email = legacy_user.email or "" + django_user.is_active = True + django_user.is_staff = legacy_user.role_code in (0, 1) + django_user.is_superuser = legacy_user.role_code == 0 + django_user.set_unusable_password() + django_user.save() + return django_user + + +def _login_legacy_user(request, legacy_user): + django_user = _sync_django_user(legacy_user) + request.session["legacy_user_id"] = legacy_user.id + request.session["legacy_role_code"] = legacy_user.role_code + login(request, django_user, backend="callpower.auth_backends.LegacyUserBackend") + + +def _require_legacy_user(request): + legacy_user = _legacy_user_from_request(request) + if not request.user.is_authenticated or not legacy_user: + return None + return legacy_user + + +def _require_admin_user(request): + legacy_user = _require_legacy_user(request) + if not legacy_user or not legacy_user.is_admin(): + return None + return legacy_user + + +def _redirect_to_login(request): + return redirect(f"{reverse('user-login')}?next={request.get_full_path()}") + + +def _page_context(request, **extra): + return { + "legacy_user": _legacy_user_from_request(request), + "sitename": settings.SITENAME, + "admin_email": settings.ADMIN_EMAIL, + **extra, + } + + +@csrf_exempt +@require_POST +def login_view(request): + try: + payload = json.loads(request.body.decode("utf-8")) + except Exception: + payload = {} + + login_value = (payload.get("login") or "").strip() + password = payload.get("password") or "" + if not login_value or not password: + return JsonResponse({"success": False, "error": "login and password are required"}, status=400) + + user = authenticate(request, username=login_value, password=password) + if not user: + return JsonResponse({"success": False, "error": "invalid login"}, status=401) + + login(request, user, backend="callpower.auth_backends.LegacyUserBackend") + legacy_user = _legacy_user_from_request(request) + if legacy_user: + legacy_user.last_accessed = timezone.now() + legacy_user.save(update_fields=["last_accessed"]) + + return JsonResponse( + { + "success": True, + "user": { + "id": legacy_user.id if legacy_user else None, + "name": legacy_user.name if legacy_user else user.username, + "email": legacy_user.email if legacy_user else user.email, + "role_code": legacy_user.role_code if legacy_user else None, + "status_code": legacy_user.status_code if legacy_user else None, + }, + } + ) + + +@csrf_exempt +@require_POST +def logout_view(request): + logout(request) + request.session.flush() + return JsonResponse({"success": True}) + + +@require_GET +def me_view(request): + legacy_user = _legacy_user_from_request(request) + if not request.user.is_authenticated or not legacy_user: + return JsonResponse({"authenticated": False}, status=401) + + return JsonResponse( + { + "authenticated": True, + "user": { + "id": legacy_user.id, + "name": legacy_user.name, + "email": legacy_user.email, + "role_code": legacy_user.role_code, + "status_code": legacy_user.status_code, + }, + } + ) + + +def login_page(request): + if _require_legacy_user(request): + return redirect("admin-app") + + form = LoginForm( + request.POST or None, + initial={ + "login": request.GET.get("login", ""), + "next": request.GET.get("next", ""), + }, + ) + + if request.method == "POST" and form.is_valid(): + login_value = form.cleaned_data["login"] + password = form.cleaned_data["password"] + user = authenticate(request, username=login_value, password=password) + legacy_user = _legacy_user_from_request(request) + if user and legacy_user: + login(request, user, backend="callpower.auth_backends.LegacyUserBackend") + legacy_user.last_accessed = timezone.now() + legacy_user.save(update_fields=["last_accessed"]) + if form.cleaned_data["remember"]: + request.session.set_expiry(60 * 60 * 24 * 14) + messages.success(request, "Logged in") + return redirect(form.cleaned_data["next"] or reverse("admin-app")) + messages.warning(request, "Sorry, invalid login") + + return render(request, "account/login.html", _page_context(request, form=form)) + + +def reauth_page(request): + legacy_user = _require_legacy_user(request) + if not legacy_user: + return _redirect_to_login(request) + + form = ReauthForm( + request.POST or None, + initial={"next": request.GET.get("next", "")}, + ) + if request.method == "POST" and form.is_valid(): + if legacy_user.check_password(form.cleaned_data["password"]): + request.session["legacy_reauth_at"] = timezone.now().isoformat() + messages.success(request, "Reauthenticated.") + return redirect(form.cleaned_data["next"] or reverse("user-change-password")) + messages.warning(request, "Password is incorrect.") + + return render(request, "account/reauth.html", _page_context(request, form=form)) + + +def logout_page(request): + if request.method == "POST": + logout(request) + request.session.flush() + messages.success(request, "Logged out") + return redirect("site-index") + return render(request, "account/logout.html", _page_context(request)) + + +def create_account_page(request): + activation_key = request.GET.get("activation_key") or request.POST.get("activation_key") + email = request.GET.get("email") or request.POST.get("email") + legacy_user = ( + LegacyUser.objects.filter(activation_key=activation_key, email=email).first() + if activation_key and email + else None + ) + if legacy_user is None: + return render(request, "account/invalid_invitation.html", _page_context(request), status=404) + + form = CreateUserForm( + request.POST or None, + user=legacy_user, + initial={ + **invitation_initial(legacy_user), + "next": request.GET.get("next", ""), + }, + ) + if request.method == "POST" and form.is_valid(): + legacy_user.email = form.cleaned_data["email"] + legacy_user.name = form.cleaned_data["name"] + legacy_user.phone = form.cleaned_data["phone"] + legacy_user.set_password(form.cleaned_data["password"]) + legacy_user.status_code = USER_ACTIVE + legacy_user.last_accessed = timezone.now() + legacy_user.activation_key = None + legacy_user.save( + update_fields=[ + "email", + "name", + "phone", + "password", + "status_code", + "last_accessed", + "activation_key", + ] + ) + _login_legacy_user(request, legacy_user) + messages.success(request, "Your account is ready.") + return redirect(form.cleaned_data["next"] or reverse("admin-app")) + + return render(request, "account/create_account.html", _page_context(request, form=form)) + + +def _resolve_change_password_user(request): + legacy_user = _require_legacy_user(request) + if legacy_user: + reauth_at = request.session.get("legacy_reauth_at") + if reauth_at: + try: + reauth_time = timezone.datetime.fromisoformat(reauth_at) + if timezone.is_naive(reauth_time): + reauth_time = timezone.make_aware(reauth_time, timezone.get_current_timezone()) + except ValueError: + reauth_time = None + if reauth_time and timezone.now() - reauth_time <= REAUTH_WINDOW: + return legacy_user, None + return None, redirect(f"{reverse('user-reauth')}?next={reverse('user-change-password')}") + + activation_key = request.GET.get("activation_key") or request.POST.get("activation_key") + email = request.GET.get("email") or request.POST.get("email") + if not activation_key or not email: + return None, None + return LegacyUser.objects.filter(activation_key=activation_key, email=email).first(), None + + +def change_password_page(request): + legacy_user, redirect_response = _resolve_change_password_user(request) + if redirect_response: + return redirect_response + if legacy_user is None: + return render(request, "account/forbidden.html", _page_context(request), status=403) + + form = ChangePasswordForm( + request.POST or None, + initial={"email": legacy_user.email, "activation_key": legacy_user.activation_key or ""}, + ) + if request.method == "POST" and form.is_valid(): + legacy_user.set_password(form.cleaned_data["password"]) + legacy_user.activation_key = None + legacy_user.save(update_fields=["password", "activation_key"]) + request.session.pop("legacy_reauth_at", None) + logout(request) + request.session.flush() + messages.success(request, "Your password has been changed, please log in again") + return redirect("user-login") + + return render( + request, + "account/change_password.html", + _page_context(request, legacy_user_record=legacy_user, form=form), + ) + + +def reset_password_page(request): + form = RecoverPasswordForm(request.POST or None) + if request.method == "POST" and form.is_valid(): + messages.success( + request, + "If that address is associated with an account you'll receive a password reset email shortly.", + ) + legacy_user = LegacyUser.objects.filter(email__iexact=form.cleaned_data["email"]).first() + if legacy_user: + legacy_user.activation_key = str(uuid4()) + legacy_user.save(update_fields=["activation_key"]) + url = request.build_absolute_uri( + reverse("user-change-password") + + f"?email={legacy_user.email}&activation_key={legacy_user.activation_key}" + ) + body = render_to_string( + "account/email/reset_password.txt", + { + "sitename": settings.SITENAME, + "username": legacy_user.name, + "url": url, + }, + ) + send_mail( + subject=f"Reset your password for {settings.SITENAME}", + message=body, + from_email=settings.DEFAULT_FROM_EMAIL, + recipient_list=[legacy_user.email], + fail_silently=False, + ) + return redirect("user-reset-password") + + return render(request, "account/reset_password.html", _page_context(request, form=form)) + + +def profile_page(request, user_id=None): + legacy_user = _require_legacy_user(request) + if not legacy_user: + return _redirect_to_login(request) + + target_user = get_object_or_404(LegacyUser, pk=user_id) if user_id else legacy_user + if target_user.pk != legacy_user.pk and not legacy_user.is_admin(): + return render(request, "account/forbidden.html", _page_context(request), status=403) + + form = UserForm(request.POST or None, user=target_user, initial=profile_initial(target_user)) + if request.method == "POST" and form.is_valid(): + target_user.email = form.cleaned_data["email"] + target_user.name = form.cleaned_data["name"] + target_user.phone = form.cleaned_data["phone"] + target_user.save(update_fields=["email", "name", "phone"]) + _sync_django_user(target_user) + messages.success(request, "User profile updated.") + return redirect(reverse("user-profile-id", args=[target_user.id]) if user_id else reverse("user-profile")) + + return render( + request, + "account/profile.html", + _page_context(request, target_user=target_user, form=form), + ) + + +def invite_page(request): + legacy_user = _require_admin_user(request) + if not legacy_user: + return _redirect_to_login(request) if not _require_legacy_user(request) else render( + request, "account/forbidden.html", _page_context(request), status=403 + ) + + form = InviteUserForm(request.POST or None) + if request.method == "POST" and form.is_valid(): + invitee = LegacyUser( + name=form.cleaned_data["name"], + email=form.cleaned_data["email"], + activation_key=str(uuid4()), + status_code=USER_NEW, + role_code=legacy_user.role_code if legacy_user.role_code != USER_ADMIN else 1, + created_time=timezone.now(), + ) + invitee.set_password(invitee.activation_key) + invitee.save() + + url = request.build_absolute_uri( + reverse("user-create-account") + + f"?email={invitee.email}&activation_key={invitee.activation_key}" + ) + body = render_to_string( + "account/email/invite_user.txt", + { + "sitename": settings.SITENAME, + "username": invitee.name, + "url": url, + }, + ) + send_mail( + subject=f"Create account on {settings.SITENAME}", + message=body, + from_email=settings.DEFAULT_FROM_EMAIL, + recipient_list=[invitee.email], + fail_silently=False, + ) + messages.success(request, f"Invited {invitee.email}") + return redirect("user-index") + + return render(request, "account/invite.html", _page_context(request, form=form)) + + +def index_page(request): + legacy_user = _require_admin_user(request) + if not legacy_user: + return _redirect_to_login(request) if not _require_legacy_user(request) else render( + request, "account/forbidden.html", _page_context(request), status=403 + ) + users = LegacyUser.objects.order_by("name", "id") + return render(request, "account/list.html", _page_context(request, users=users)) + + +def role_page(request, user_id): + legacy_user = _require_admin_user(request) + if not legacy_user: + return _redirect_to_login(request) if not _require_legacy_user(request) else render( + request, "account/forbidden.html", _page_context(request), status=403 + ) + target_user = get_object_or_404(LegacyUser, pk=user_id) + form = UserRoleForm( + request.POST or None, + initial={ + "role_code": str(target_user.role_code), + "status_code": str(target_user.status_code), + "next": request.GET.get("next", ""), + }, + ) + if request.method == "POST" and form.is_valid(): + if target_user.pk == legacy_user.pk and target_user.role_code == USER_ADMIN and form.cleaned_data["role_code"] > USER_ADMIN: + messages.warning(request, "Cannot remove your own admin role.") + else: + target_user.role_code = form.cleaned_data["role_code"] + target_user.status_code = form.cleaned_data["status_code"] + target_user.save(update_fields=["role_code", "status_code"]) + _sync_django_user(target_user) + messages.success(request, f"Updated {target_user.email}.") + return redirect(form.cleaned_data["next"] or reverse("user-index")) + + return render(request, "account/role.html", _page_context(request, target_user=target_user, form=form)) + + +def remove_page(request, user_id): + legacy_user = _require_admin_user(request) + if not legacy_user: + return _redirect_to_login(request) if not _require_legacy_user(request) else render( + request, "account/forbidden.html", _page_context(request), status=403 + ) + target_user = get_object_or_404(LegacyUser, pk=user_id) + if target_user.pk == legacy_user.pk: + messages.warning(request, "Cannot remove your own account.") + return redirect("user-index") + + form = RemoveUserForm(request.POST or None, initial={"username": target_user.name}) + if request.method == "POST" and form.is_valid(): + User.objects.filter(username=f"legacy-{target_user.id}").delete() + target_user.delete() + messages.success(request, f"Removed {target_user.email}.") + return redirect("user-index") + + return render(request, "account/remove.html", _page_context(request, target_user=target_user, form=form)) + + +@require_POST +def language_view(request): + language_code = (request.POST.get("lang") or request.POST.get("language") or "").strip() + if language_code: + request.session["django_language"] = language_code + return JsonResponse({"success": True, "language": language_code}) diff --git a/django_app/callpower/apps/calls/__init__.py b/django_app/callpower/apps/calls/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/django_app/callpower/apps/calls/apps.py b/django_app/callpower/apps/calls/apps.py new file mode 100644 index 00000000..85f0f8d4 --- /dev/null +++ b/django_app/callpower/apps/calls/apps.py @@ -0,0 +1,6 @@ +from django.apps import AppConfig + + +class CallsConfig(AppConfig): + default_auto_field = "django.db.models.BigAutoField" + name = "callpower.apps.calls" diff --git a/django_app/callpower/apps/calls/urls.py b/django_app/callpower/apps/calls/urls.py new file mode 100644 index 00000000..62eaf885 --- /dev/null +++ b/django_app/callpower/apps/calls/urls.py @@ -0,0 +1,17 @@ +from django.urls import path + +from callpower.apps.calls import views + + +urlpatterns = [ + path("create", views.create, name="call-create"), + path("incoming", views.incoming, name="call-incoming"), + path("connection", views.connection, name="call-connection"), + path("location_parse", views.location_parse, name="call-location-parse"), + path("schedule_parse", views.schedule_parse, name="call-schedule-parse"), + path("make_calls", views.make_calls, name="call-make-calls"), + path("make_single", views.make_single, name="call-make-single"), + path("complete", views.complete, name="call-complete"), + path("status_callback", views.status_callback, name="call-status-callback"), + path("status_inbound", views.status_inbound, name="call-status-inbound"), +] diff --git a/django_app/callpower/apps/calls/views.py b/django_app/callpower/apps/calls/views.py new file mode 100644 index 00000000..6a11c60a --- /dev/null +++ b/django_app/callpower/apps/calls/views.py @@ -0,0 +1,669 @@ +import hashlib +import random +from urllib.parse import urlencode + +import phonenumbers +import pystache +from django.conf import settings +from django.db import transaction +from django.http import HttpResponse, JsonResponse +from django.urls import reverse +from django.utils import timezone +from django.views.decorators.csrf import csrf_exempt +from django.views.decorators.http import require_http_methods +from twilio.rest import Client +from twilio.twiml.voice_response import Dial, Gather, VoiceResponse + +from callpower.apps.core.models import Call, Campaign, ScheduleCall, Session, Target +from callpower.apps.political_data.lookup import locate_targets, validate_location +from callpower.apps.political_data.services import ensure_target_from_key + + +SEGMENT_BY_LOCATION = "location" +SEGMENT_BY_CUSTOM = "custom" +LOCATION_POSTAL = "postal" +LOCATION_DISTRICT = "district" +TWILIO_TTS_LANGUAGES = { + "da-DK", + "de-DE", + "en-AU", + "en-CA", + "en-GB", + "en-IN", + "en-US", + "ca-ES", + "es-ES", + "es-MX", + "fi-FI", + "fr-CA", + "fr-FR", + "it-IT", + "ja-JP", + "ko-KR", + "nb-NO", + "nl-NL", + "pl-PL", + "pt-BR", + "pt-PT", + "ru-RU", + "sv-SE", + "zh-CN", + "zh-HK", + "zh-TW", +} + + +def twiml_response(response): + return HttpResponse(str(response), content_type="text/xml") + + +def json_error(message, status=400): + return JsonResponse({"status": status, "error": message}, status=status) + + +def request_data(request): + return request.POST if request.method == "POST" else request.GET + + +def build_url(request, route_name, params): + return request.build_absolute_uri(f"{reverse(route_name)}?{urlencode(params, doseq=True)}") + + +def normalize_phone(number, country_code="US"): + try: + parsed = phonenumbers.parse(number, country_code) + return phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164) + except phonenumbers.NumberParseException: + return number + + +def hash_phone(number): + return hashlib.sha256(number.encode("ascii")).hexdigest() + + +def twilio_client(): + if not settings.TWILIO_ACCOUNT_SID or not settings.TWILIO_AUTH_TOKEN: + raise RuntimeError("Missing Twilio credentials") + return Client(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN) + + +def campaign_phone_numbers(campaign, region_code=None): + links = campaign.campaign_phone_links.select_related("phone").all() + numbers = [] + for link in links: + if link.phone and link.phone.number: + numbers.append(link.phone.number) + return numbers + + +def campaign_language(campaign): + if campaign.campaign_language and campaign.country_code: + value = f"{campaign.campaign_language.lower()}-{campaign.country_code.upper()}" + else: + value = "en-US" + return value if value in TWILIO_TTS_LANGUAGES else "en-US" + + +def play_or_say(response, audio, *, lang="en-US", **kwargs): + if not audio: + response.say("Error: no recording defined", voice="alice", language=lang) + return + + if hasattr(audio, "text_to_speech") and audio.text_to_speech: + message = pystache.render(audio.text_to_speech, kwargs) + response.say(message, voice="alice", language=lang) + return + + if hasattr(audio, "file_url"): + file_url = audio.file_url() + if file_url: + response.play(file_url) + return + + if isinstance(audio, str): + try: + rendered = pystache.render(audio, kwargs) + except Exception: + rendered = audio + response.say(rendered, voice="alice", language=lang) + return + + response.say("Error: unsupported audio type", voice="alice", language=lang) + + +def parse_params(request, inbound=False): + data = request_data(request) + params = { + "campaign_id": data.get("campaignId"), + "scheduled": data.get("scheduled"), + "schedule_skip": data.get("scheduleSkip"), + "session_id": data.get("sessionId"), + "target_ids": data.getlist("targetIds") if hasattr(data, "getlist") else [], + "user_phone": data.get("userPhone"), + "user_country": (data.get("userCountry") or "US").upper(), + "user_location": data.get("userLocation"), + "user_ip_address": data.get("userIPAddress") or request.META.get("REMOTE_ADDR"), + } + + if not params["campaign_id"]: + raise ValueError("campaignId required") + if not inbound and not params["user_phone"]: + raise ValueError("userPhone required") + + campaign = Campaign.objects.filter(pk=params["campaign_id"]).first() + if not campaign: + campaign = Campaign.objects.filter(name=params["campaign_id"]).first() + if not campaign: + raise ValueError(f"invalid campaignId {params['campaign_id']}") + + return params, campaign + + +def ordered_campaign_targets(campaign): + links = campaign.campaign_target_links.select_related("target").order_by("order", "id").all() + return [link.target for link in links if link.target] + + +def resolve_targets(params, campaign): + if params["target_ids"]: + targets = [] + for value in params["target_ids"]: + target = Target.objects.filter(key=value).first() or ensure_target_from_key(value) + if target: + targets.append(target) + return targets + + if campaign.segment_by == SEGMENT_BY_CUSTOM: + targets = ordered_campaign_targets(campaign) + if campaign.target_ordering == "shuffle": + random.shuffle(targets) + return targets + + if campaign.segment_by == SEGMENT_BY_LOCATION and params.get("user_location"): + keys = locate_targets(params["user_location"], campaign) + return [ensure_target_from_key(key) for key in keys] + + return ordered_campaign_targets(campaign) + + +def intro_wait_human(request, params, campaign): + resp = VoiceResponse() + play_or_say(resp, campaign.audio("msg_intro"), lang=campaign_language(campaign), name=campaign.name) + action = build_url(request, "call-make-calls", twilio_params(params)) + gather = Gather(num_digits=1, timeout=10, method="POST", action=action) + play_or_say(gather, campaign.audio("msg_intro_confirm"), lang=campaign_language(campaign)) + resp.append(gather) + gather_fallback = Gather(num_digits=1, timeout=10, method="POST", action=action) + play_or_say(gather_fallback, "Press the star key to get started.", lang="en-US") + resp.append(gather_fallback) + play_or_say(resp, campaign.audio("msg_goodbye"), lang=campaign_language(campaign)) + return twiml_response(resp) + + +def intro_location_gather(request, params, campaign): + resp = VoiceResponse() + audio = campaign.audio("msg_intro_location") or campaign.audio("msg_intro") + play_or_say(resp, audio, lang=campaign_language(campaign), organization="") + return location_gather(request, resp, params, campaign) + + +def location_gather(request, resp, params, campaign): + action = build_url(request, "call-location-parse", twilio_params(params)) + gather = Gather(num_digits=5, timeout=10, method="POST", action=action) + play_or_say(gather, campaign.audio("msg_location"), lang=campaign_language(campaign)) + resp.append(gather) + play_or_say(resp, campaign.audio("msg_unparsed_location"), lang=campaign_language(campaign)) + return twiml_response(resp) + + +def twilio_params(params): + data = { + "campaignId": params["campaign_id"], + "scheduled": params.get("scheduled") or "", + "scheduleSkip": params.get("schedule_skip") or "", + "sessionId": params.get("session_id") or "", + "userPhone": params.get("user_phone") or "", + "userCountry": params.get("user_country") or "", + "userLocation": params.get("user_location") or "", + "userIPAddress": params.get("user_ip_address") or "", + } + target_ids = params.get("target_ids") or [] + if target_ids: + data["targetIds"] = target_ids + return data + + +def schedule_call_for_user(campaign, phone, *, location=None, schedule_time=None, country_code="US"): + normalized_phone = normalize_phone(phone, country_code) + schedule_call, _created = ScheduleCall.objects.get_or_create( + campaign=campaign, + phone_number=normalized_phone, + ) + schedule_call.time_to_call = schedule_time or timezone.now().time().replace(second=0, microsecond=0) + schedule_call.start_job(location=location) + return schedule_call + + +def delete_schedule_call_for_user(campaign, phone, country_code="US"): + normalized_phone = normalize_phone(phone, country_code) + schedule_call = ScheduleCall.objects.filter(campaign=campaign, phone_number=normalized_phone).first() + if not schedule_call: + return None + schedule_call.stop_job() + return schedule_call + + +def schedule_prompt(request, params, campaign): + resp = VoiceResponse() + action = build_url(request, "call-schedule-parse", twilio_params(params)) + gather = Gather(num_digits=1, timeout=3, method="POST", action=action) + + normalized_phone = normalize_phone(params["user_phone"], params["user_country"]) + existing_schedule = ScheduleCall.objects.filter( + campaign=campaign, + phone_number=normalized_phone, + subscribed=True, + ).first() + if existing_schedule: + play_or_say(gather, campaign.audio("msg_alter_schedule"), lang=campaign_language(campaign)) + else: + play_or_say(gather, campaign.audio("msg_prompt_schedule"), lang=campaign_language(campaign)) + + resp.append(gather) + redirect_params = twilio_params({**params, "schedule_skip": 1}) + resp.redirect(build_url(request, "call-make-calls", redirect_params)) + return twiml_response(resp) + + +def session_from_params(params): + if not params.get("session_id"): + return None + return Session.objects.filter(pk=params["session_id"]).first() + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def create(request): + try: + params, campaign = parse_params(request) + except ValueError as exc: + return json_error(str(exc)) + + phone_numbers = campaign_phone_numbers(campaign, params["user_country"]) + if not phone_numbers: + return json_error("no numbers available for campaign in region") + + user_phone = normalize_phone(params["user_phone"], params["user_country"]) + targets = resolve_targets(params, campaign) + if campaign.call_maximum: + targets = targets[: campaign.call_maximum] + params["target_ids"] = [target.key for target in targets if target.key] + + from_number = random.choice(phone_numbers) + session = Session( + campaign=campaign, + timestamp=timezone.now(), + location=params["user_location"], + from_number=from_number, + status="initiated", + direction="outbound", + ) + if settings.LOG_PHONE_NUMBERS and params["user_phone"]: + session.phone_hash = hash_phone(params["user_phone"]) + ref = request_data(request).get("ref") + if ref: + session.referral_code = ref[:64] + session.save() + params["session_id"] = session.id + + try: + call = twilio_client().calls.create( + to=user_phone, + from_=from_number, + url=build_url(request, "call-connection", twilio_params(params)), + timeout=settings.TWILIO_TIMEOUT, + status_callback=build_url(request, "call-status-callback", twilio_params(params)), + status_callback_event=["ringing", "completed"], + record=bool(request_data(request).get("record", False)), + ) + except Exception as exc: + return json_error(str(exc)) + + target_response = { + "segment": campaign.segment_by, + "objects": [ + {"name": target.name, "title": target.title, "phone": target.number} + for target in targets + if target.number + ], + } + embed = campaign.embed or {} + return JsonResponse( + { + "campaign": {0: "archived", 1: "paused", 2: "live"}.get(campaign.status_code, "unknown"), + "call": call.status, + "script": embed.get("script", ""), + "redirect": embed.get("redirect", ""), + "fromNumber": from_number, + "targets": target_response, + }, + status=200 if call.status != "failed" else 500, + ) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def incoming(request): + try: + params, campaign = parse_params(request, inbound=True) + except ValueError as exc: + return json_error(str(exc)) + + if campaign.status_code == 0: + resp = VoiceResponse() + play_or_say(resp, campaign.audio("msg_campaign_complete"), lang=campaign_language(campaign)) + return twiml_response(resp) + + params["user_phone"] = request_data(request).get("From") + campaign_number = request_data(request).get("To") + session = Session( + campaign=campaign, + timestamp=timezone.now(), + from_number=campaign_number, + status="initiated", + direction="inbound", + ) + if settings.LOG_PHONE_NUMBERS and params["user_phone"]: + session.phone_hash = hash_phone(params["user_phone"]) + session.save() + params["session_id"] = session.id + + if campaign.segment_by == SEGMENT_BY_LOCATION and campaign.locate_by in [LOCATION_POSTAL, LOCATION_DISTRICT]: + return intro_location_gather(request, params, campaign) + return intro_wait_human(request, params, campaign) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def connection(request): + try: + params, campaign = parse_params(request) + except ValueError as exc: + return json_error(str(exc)) + + if campaign.segment_by == SEGMENT_BY_LOCATION and campaign.locate_by in [LOCATION_POSTAL, LOCATION_DISTRICT] and not params["user_location"]: + return intro_location_gather(request, params, campaign) + return intro_wait_human(request, params, campaign) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def location_parse(request): + try: + params, campaign = parse_params(request) + except ValueError as exc: + return json_error(str(exc)) + + location = request_data(request).get("Digits", "")[:5] + if not location: + resp = VoiceResponse() + play_or_say(resp, campaign.audio("msg_unparsed_location"), lang=campaign_language(campaign)) + return location_gather(request, resp, params, campaign) + + if not validate_location(location, campaign): + resp = VoiceResponse() + play_or_say(resp, campaign.audio("msg_invalid_location"), lang=campaign_language(campaign), location=location) + return location_gather(request, resp, params, campaign) + + params["user_location"] = location + session = session_from_params(params) + if session and not session.location: + session.location = location + session.save(update_fields=["location"]) + resp = VoiceResponse() + resp.redirect(build_url(request, "call-make-calls", twilio_params(params))) + return twiml_response(resp) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def make_calls(request): + try: + params, campaign = parse_params(request) + except ValueError as exc: + return json_error(str(exc)) + + if campaign.prompt_schedule and not params.get("schedule_skip"): + return schedule_prompt(request, params, campaign) + + targets = resolve_targets(params, campaign) + if campaign.call_maximum: + targets = targets[: campaign.call_maximum] + params["target_ids"] = [target.key for target in targets if target.key] + + resp = VoiceResponse() + if not params["target_ids"]: + play_or_say( + resp, + campaign.audio("msg_invalid_location"), + lang=campaign_language(campaign), + location=params.get("user_location", ""), + ) + resp.hangup() + return twiml_response(resp) + + play_or_say( + resp, + campaign.audio("msg_call_block_intro"), + lang=campaign_language(campaign), + n_targets=len(params["target_ids"]), + many=len(params["target_ids"]) > 1, + ) + redirect_params = twilio_params(params) + redirect_params["call_index"] = 0 + resp.redirect(build_url(request, "call-make-single", redirect_params)) + return twiml_response(resp) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def make_single(request): + try: + params, campaign = parse_params(request) + except ValueError as exc: + return json_error(str(exc)) + + call_index = int(request_data(request).get("call_index", 0)) + targets = resolve_targets(params, campaign) + if call_index >= len(targets): + resp = VoiceResponse() + play_or_say(resp, campaign.audio("msg_final_thanks"), lang=campaign_language(campaign)) + return twiml_response(resp) + + target = targets[call_index] + if not target.number: + resp = VoiceResponse() + play_or_say(resp, campaign.audio("msg_invalid_location"), lang=campaign_language(campaign)) + redirect_params = twilio_params(params) + redirect_params["call_index"] = call_index + 1 + resp.redirect(build_url(request, "call-make-single", redirect_params)) + return twiml_response(resp) + + resp = VoiceResponse() + play_or_say( + resp, + campaign.audio("msg_target_intro"), + lang=campaign_language(campaign), + title=target.title or "", + name=target.name, + location=target.location or "capitol", + office_type="main", + district=target.district or "", + ) + user_phone = normalize_phone(params["user_phone"], params["user_country"]) + dial = Dial( + caller_id=user_phone, + time_limit=settings.TWILIO_TIME_LIMIT, + timeout=settings.TWILIO_TIMEOUT, + hangup_on_star=True, + action=build_url( + request, + "call-complete", + {**twilio_params(params), "call_index": call_index}, + ), + ) + dial.number(target.number) + resp.append(dial) + return twiml_response(resp) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def schedule_parse(request): + try: + params, campaign = parse_params(request) + except ValueError as exc: + return json_error(str(exc)) + + resp = VoiceResponse() + schedule_choice = request_data(request).get("Digits", "") + + if schedule_choice == "1": + play_or_say(resp, campaign.audio("msg_schedule_start"), lang=campaign_language(campaign)) + schedule_call_for_user( + campaign, + params["user_phone"], + location=params.get("user_location"), + country_code=params["user_country"], + ) + elif schedule_choice == "9": + play_or_say(resp, campaign.audio("msg_schedule_stop"), lang=campaign_language(campaign)) + delete_schedule_call_for_user( + campaign, + params["user_phone"], + country_code=params["user_country"], + ) + + redirect_params = twilio_params({**params, "schedule_skip": 1}) + resp.redirect(build_url(request, "call-make-calls", redirect_params)) + return twiml_response(resp) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +@transaction.atomic +def complete(request): + try: + params, campaign = parse_params(request) + except ValueError as exc: + return json_error(str(exc)) + + call_index = int(request_data(request).get("call_index", 0)) + targets = resolve_targets(params, campaign) + if call_index >= len(targets): + return twiml_response(VoiceResponse()) + + target = targets[call_index] + Call.objects.create( + session_id=params["session_id"], + campaign=campaign, + target=target, + timestamp=timezone.now(), + call_id=request_data(request).get("CallSid"), + status=request_data(request).get("DialCallStatus", "unknown"), + duration=int(request_data(request).get("DialCallDuration") or 0), + ) + + resp = VoiceResponse() + if call_index == len(targets) - 1: + play_or_say(resp, campaign.audio("msg_final_thanks"), lang=campaign_language(campaign)) + else: + play_or_say( + resp, + campaign.audio("msg_between_calls"), + lang=campaign_language(campaign), + calls_left=len(targets) - call_index - 1, + ) + redirect_params = twilio_params(params) + redirect_params["call_index"] = call_index + 1 + resp.redirect(build_url(request, "call-make-single", redirect_params)) + return twiml_response(resp) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def status_callback(request): + try: + params, _campaign = parse_params(request) + except ValueError as exc: + return json_error(str(exc)) + + session = session_from_params(params) + if not session: + return JsonResponse( + { + "phoneNumber": request_data(request).get("From", ""), + "callStatus": "unknown", + "message": "no sessionId passed, unable to update status", + "campaignId": params["campaign_id"], + } + ) + + if request_data(request).get("CallStatus") == "ringing" and session.timestamp: + session.queue_delay = timezone.now() - session.timestamp + session.save(update_fields=["queue_delay"]) + + if request_data(request).get("CallDuration"): + session.status = request_data(request).get("CallStatus", "unknown") + session.duration = int(request_data(request).get("CallDuration") or 0) + session.save(update_fields=["status", "duration"]) + + return JsonResponse( + { + "phoneNumber": request_data(request).get("To", ""), + "callStatus": request_data(request).get("CallStatus"), + "targetIds": params["target_ids"], + "campaignId": params["campaign_id"], + } + ) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def status_inbound(request): + try: + params, campaign = parse_params(request, inbound=True) + except ValueError as exc: + return json_error(str(exc)) + + user_phone = request_data(request).get("From", "") + session = ( + Session.objects.filter( + phone_hash=hash_phone(user_phone) if user_phone else "", + status="initiated", + direction="inbound", + campaign=campaign, + ) + .order_by("-timestamp") + .first() + ) + if not session: + return JsonResponse( + { + "phoneNumber": user_phone, + "callStatus": "unknown", + "message": "unable to find CallSession matching campaign and phone", + "campaignId": params["campaign_id"], + } + ) + + session.status = request_data(request).get("CallStatus", "unknown") + session.duration = int(request_data(request).get("CallDuration") or 0) + session.save(update_fields=["status", "duration"]) + return JsonResponse( + { + "phoneNumber": user_phone, + "callStatus": session.status, + "campaignId": params["campaign_id"], + } + ) diff --git a/django_app/callpower/apps/core/__init__.py b/django_app/callpower/apps/core/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/django_app/callpower/apps/core/apps.py b/django_app/callpower/apps/core/apps.py new file mode 100644 index 00000000..917e2136 --- /dev/null +++ b/django_app/callpower/apps/core/apps.py @@ -0,0 +1,33 @@ +import os +import sys +from urllib.parse import urlparse + +from django.apps import AppConfig +from django.conf import settings + +class CoreConfig(AppConfig): + default_auto_field = "django.db.models.BigAutoField" + name = "callpower.apps.core" + + def ready(self): + if settings.USE_NGROK: + # Only import pyngrok and install if we're actually going to use it + from pyngrok import ngrok + + # Get the dev server port (defaults to 8000 for Django, can be overridden with the + # last arg when calling `runserver`) + addrport = urlparse(f"http://{sys.argv[-1]}") + port = addrport.port if addrport.netloc and addrport.port else "8000" + + # Open a ngrok tunnel to the dev server + public_url = ngrok.connect(port).public_url + print(f"ngrok tunnel \"{public_url}\" -> \"http://127.0.0.1:{port}\"") + + # Update any base URLs or webhooks to use the public ngrok URL + settings.BASE_URL = public_url + CoreConfig.init_webhooks(public_url) + + @staticmethod + def init_webhooks(base_url): + # ... Implement updates necessary so webhooks use `public_url` from ngrok + pass \ No newline at end of file diff --git a/django_app/callpower/apps/core/management/__init__.py b/django_app/callpower/apps/core/management/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/django_app/callpower/apps/core/management/__init__.py @@ -0,0 +1 @@ + diff --git a/django_app/callpower/apps/core/management/commands/__init__.py b/django_app/callpower/apps/core/management/commands/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/__init__.py @@ -0,0 +1 @@ + diff --git a/django_app/callpower/apps/core/management/commands/_legacy_helpers.py b/django_app/callpower/apps/core/management/commands/_legacy_helpers.py new file mode 100644 index 00000000..ce5b4236 --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/_legacy_helpers.py @@ -0,0 +1,146 @@ +from __future__ import annotations + +from datetime import datetime +from getpass import getpass + +from django.core.management.base import CommandError +from django.utils import timezone +from werkzeug.security import generate_password_hash + +from callpower.apps.core.models import Campaign, CampaignTarget, LegacyUser, ScheduleCall +from callpower.apps.political_data.registry import COUNTRY_DATA, get_country_data +from callpower.apps.political_data.services import ensure_target_from_key + + +USER_ADMIN = 0 +USER_ACTIVE = 2 +USERNAME_LEN_MIN = 4 +USERNAME_LEN_MAX = 25 +PASSWORD_LEN_MIN = 6 +PASSWORD_LEN_MAX = 64 + + +def load_political_data(stdout): + loaded = 0 + for country_code in COUNTRY_DATA: + provider = get_country_data(country_code) + loaded += provider.load_data() + stdout.write(f"Loaded political data for {country_code.upper()}") + return loaded + + +def fix_targets(campaign_id, stdout): + campaign = Campaign.objects.filter(pk=campaign_id).first() + if not campaign: + raise CommandError(f"Campaign {campaign_id} does not exist.") + + target_keys = list( + campaign.campaign_target_links.select_related("target") + .order_by("order", "id") + .values_list("target__key", flat=True) + ) + unique_keys = [key for key in dict.fromkeys(target_keys) if key] + stdout.write(f"Got {len(target_keys)} targets, {len(unique_keys)} unique") + + CampaignTarget.objects.filter(campaign=campaign).delete() + created_links = 0 + for index, target_key in enumerate(unique_keys): + target = ensure_target_from_key(target_key) + CampaignTarget.objects.create( + campaign=campaign, + target=target, + order=index, + ) + created_links += 1 + stdout.write(f"{index}: {target_key}") + + return campaign, created_links + + +def create_admin_user(username=None, password=None, email=None, stdin=None): + stdin = stdin or input + + if username and LegacyUser.objects.filter(name=username).exists(): + raise CommandError(f"username {username} already exists") + + while username is None: + candidate = stdin("Username: ").strip() + if len(candidate) < USERNAME_LEN_MIN: + print(f"username too short, must be at least {USERNAME_LEN_MIN} characters") + continue + if len(candidate) > USERNAME_LEN_MAX: + print(f"username too long, must be less than {USERNAME_LEN_MAX} characters") + continue + if LegacyUser.objects.filter(name=candidate).exists(): + print("username already exists") + continue + username = candidate + + while email is None: + candidate = stdin("Email: ").strip() + if candidate: + email = candidate + + while password is None: + candidate = getpass("Password: ") + password_confirm = getpass("Confirm: ") + if candidate != password_confirm: + print("passwords don't match") + continue + if len(candidate) < PASSWORD_LEN_MIN or len(candidate) > PASSWORD_LEN_MAX: + print(f"password length must be between {PASSWORD_LEN_MIN} and {PASSWORD_LEN_MAX} characters") + continue + password = candidate + + now = timezone.now() + user = LegacyUser.objects.create( + name=username, + email=email, + password=generate_password_hash(password), + role_code=USER_ADMIN, + status_code=USER_ACTIVE, + created_time=now, + last_accessed=now, + ) + return user + + +def stop_scheduled_calls(campaign_id, before_date, accept_all=False): + campaign = Campaign.objects.filter(pk=campaign_id).first() + if not campaign: + raise CommandError(f"Campaign {campaign_id} does not exist.") + + if isinstance(before_date, str): + before_date = datetime.strptime(before_date, "%Y-%m-%d") + aware_before = timezone.make_aware(before_date) if timezone.is_naive(before_date) else before_date + + scheduled_calls = list( + ScheduleCall.objects.filter(campaign=campaign, created_at__lte=aware_before).order_by("id") + ) + if not accept_all: + raise CommandError("This command requires --accept-all in the Django migration.") + + for scheduled_call in scheduled_calls: + scheduled_call.stop_job() + return campaign, scheduled_calls + + +def restart_scheduled_calls(campaign_id, accept_all=False): + if not accept_all: + raise CommandError("This command requires --accept-all in the Django migration.") + + if campaign_id == "all": + campaigns = Campaign.objects.filter(prompt_schedule=True, status_code=2).order_by("id") + else: + campaign = Campaign.objects.filter(pk=campaign_id).first() + if not campaign: + raise CommandError(f"Campaign {campaign_id} does not exist.") + campaigns = [campaign] + + updated = [] + for campaign in campaigns: + scheduled_calls = list(ScheduleCall.objects.filter(campaign=campaign, subscribed=True).order_by("id")) + for scheduled_call in scheduled_calls: + scheduled_call.start_job() + updated.append((campaign, scheduled_calls)) + return updated diff --git a/django_app/callpower/apps/core/management/commands/createadminuser.py b/django_app/callpower/apps/core/management/commands/createadminuser.py new file mode 100644 index 00000000..7ed64986 --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/createadminuser.py @@ -0,0 +1,20 @@ +from django.core.management.base import BaseCommand + +from ._legacy_helpers import create_admin_user + + +class Command(BaseCommand): + help = "Create a legacy admin user that can sign into the Django-migrated admin." + + def add_arguments(self, parser): + parser.add_argument("--username", default=None) + parser.add_argument("--password", default=None) + parser.add_argument("--email", default=None) + + def handle(self, *args, **options): + user = create_admin_user( + username=options["username"], + password=options["password"], + email=options["email"], + ) + self.stdout.write(self.style.SUCCESS(f"created admin user {user.name}")) diff --git a/django_app/callpower/apps/core/management/commands/crmsync.py b/django_app/callpower/apps/core/management/commands/crmsync.py new file mode 100644 index 00000000..b529f181 --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/crmsync.py @@ -0,0 +1,32 @@ +from django.core.management.base import BaseCommand, CommandError + +from callpower.apps.core.models import SyncCampaign +from callpower.crm_sync.service import sync_campaign_calls + + +class Command(BaseCommand): + help = "Run CRM sync for one campaign or all configured sync campaigns." + + def add_arguments(self, parser): + parser.add_argument("campaigns", nargs="?", default="all") + + def handle(self, *args, **options): + campaign_arg = options["campaigns"] + if campaign_arg == "all": + sync_campaigns = SyncCampaign.objects.select_related("campaign").all() + elif "," in campaign_arg: + ids = [value.strip() for value in campaign_arg.split(",") if value.strip()] + sync_campaigns = SyncCampaign.objects.select_related("campaign").filter(campaign_id__in=ids) + else: + sync_campaigns = SyncCampaign.objects.select_related("campaign").filter(campaign_id=campaign_arg) + + if not sync_campaigns: + raise CommandError("No matching sync campaigns found.") + + for sync_campaign in sync_campaigns: + result = sync_campaign_calls(sync_campaign) + self.stdout.write( + self.style.SUCCESS( + f"campaign {sync_campaign.campaign_id}: attempted={result['attempted']} saved={result['saved']} skipped={result['skipped']}" + ) + ) diff --git a/django_app/callpower/apps/core/management/commands/fixtargets.py b/django_app/callpower/apps/core/management/commands/fixtargets.py new file mode 100644 index 00000000..c3536a58 --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/fixtargets.py @@ -0,0 +1,16 @@ +from django.core.management.base import BaseCommand + +from ._legacy_helpers import fix_targets + + +class Command(BaseCommand): + help = "Deduplicate a campaign's targets and recreate campaign target links." + + def add_arguments(self, parser): + parser.add_argument("campaign_id", type=int) + + def handle(self, *args, **options): + campaign, created_links = fix_targets(options["campaign_id"], self.stdout) + self.stdout.write( + self.style.SUCCESS(f"Rebuilt {created_links} target links for campaign {campaign.id} ({campaign.name}).") + ) diff --git a/django_app/callpower/apps/core/management/commands/loadpoliticaldata.py b/django_app/callpower/apps/core/management/commands/loadpoliticaldata.py new file mode 100644 index 00000000..82df18db --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/loadpoliticaldata.py @@ -0,0 +1,11 @@ +from django.core.management.base import BaseCommand + +from ._legacy_helpers import load_political_data + + +class Command(BaseCommand): + help = "Load political data into the Django-backed cache." + + def handle(self, *args, **options): + total = load_political_data(self.stdout) + self.stdout.write(self.style.SUCCESS(f"Loaded {total} political data objects.")) diff --git a/django_app/callpower/apps/core/management/commands/migration.py b/django_app/callpower/apps/core/management/commands/migration.py new file mode 100644 index 00000000..3896cce2 --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/migration.py @@ -0,0 +1,15 @@ +from django.core.management.base import BaseCommand, CommandError + + +class Command(BaseCommand): + help = "Compatibility shim for the legacy Flask/Alembic migration generator." + + def add_arguments(self, parser): + parser.add_argument("message") + + def handle(self, *args, **options): + raise CommandError( + "The legacy Alembic `migration` command is not used in the Django stack. " + "Use `python3 manage.py makemigrations` for managed Django apps, or edit the legacy schema directly " + "only when you intentionally keep these tables unmanaged." + ) diff --git a/django_app/callpower/apps/core/management/commands/redis_clear.py b/django_app/callpower/apps/core/management/commands/redis_clear.py new file mode 100644 index 00000000..0c790248 --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/redis_clear.py @@ -0,0 +1,15 @@ +from django.core.cache import cache +from django.core.management.base import BaseCommand, CommandError + + +class Command(BaseCommand): + help = "Clear the Django cache store used by the migrated app." + + def add_arguments(self, parser): + parser.add_argument("--accept-all", action="store_true", dest="accept_all") + + def handle(self, *args, **options): + if not options["accept_all"]: + raise CommandError("This command requires --accept-all in the Django migration.") + cache.clear() + self.stdout.write(self.style.SUCCESS("Django cache cleared.")) diff --git a/django_app/callpower/apps/core/management/commands/restart_scheduled_calls.py b/django_app/callpower/apps/core/management/commands/restart_scheduled_calls.py new file mode 100644 index 00000000..b3ae76eb --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/restart_scheduled_calls.py @@ -0,0 +1,20 @@ +from django.core.management.base import BaseCommand + +from ._legacy_helpers import restart_scheduled_calls + + +class Command(BaseCommand): + help = "Rebind subscribed scheduled calls for one campaign or all live scheduled campaigns." + + def add_arguments(self, parser): + parser.add_argument("campaign_id") + parser.add_argument("--accept-all", action="store_true", dest="accept_all") + + def handle(self, *args, **options): + updated = restart_scheduled_calls( + options["campaign_id"], + accept_all=options["accept_all"], + ) + for campaign, scheduled_calls in updated: + self.stdout.write(f"Scheduled calls for {campaign.name}: {len(scheduled_calls)}") + self.stdout.write(self.style.SUCCESS("Scheduled calls rebound into the Django scheduler.")) diff --git a/django_app/callpower/apps/core/management/commands/runjobs.py b/django_app/callpower/apps/core/management/commands/runjobs.py new file mode 100644 index 00000000..60df13f6 --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/runjobs.py @@ -0,0 +1,25 @@ +from time import sleep + +from django.core.management.base import BaseCommand + +from callpower.apps.core.scheduler import run_due_jobs + + +class Command(BaseCommand): + help = "Run due Django-managed recurring jobs for scheduled calls and CRM sync." + + def add_arguments(self, parser): + parser.add_argument("--once", action="store_true") + parser.add_argument("--poll-seconds", type=int, default=15, dest="poll_seconds") + + def handle(self, *args, **options): + once = options["once"] + poll_seconds = max(1, options["poll_seconds"]) + + while True: + results = run_due_jobs() + for result in results: + self.stdout.write(f"{result['kind']} {result['job']}: {result['status']}") + if once: + return + sleep(poll_seconds) diff --git a/django_app/callpower/apps/core/management/commands/stamp.py b/django_app/callpower/apps/core/management/commands/stamp.py new file mode 100644 index 00000000..b4c9c3c3 --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/stamp.py @@ -0,0 +1,14 @@ +from django.core.management.base import BaseCommand, CommandError + + +class Command(BaseCommand): + help = "Compatibility shim for the legacy Alembic stamp command." + + def add_arguments(self, parser): + parser.add_argument("revision") + + def handle(self, *args, **options): + raise CommandError( + "Alembic revision stamping is not part of the Django migration path. " + "Use Django's built-in migration commands for managed apps." + ) diff --git a/django_app/callpower/apps/core/management/commands/stop_scheduled_calls.py b/django_app/callpower/apps/core/management/commands/stop_scheduled_calls.py new file mode 100644 index 00000000..3fdfaf25 --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/stop_scheduled_calls.py @@ -0,0 +1,26 @@ +from datetime import date + +from django.core.management.base import BaseCommand + +from ._legacy_helpers import stop_scheduled_calls + + +class Command(BaseCommand): + help = "Unsubscribe scheduled calls created before a date." + + def add_arguments(self, parser): + parser.add_argument("campaign_id", type=int) + parser.add_argument("date", nargs="?", default=date.today().isoformat()) + parser.add_argument("--accept-all", action="store_true", dest="accept_all") + + def handle(self, *args, **options): + campaign, scheduled_calls = stop_scheduled_calls( + options["campaign_id"], + options["date"], + accept_all=options["accept_all"], + ) + self.stdout.write( + self.style.SUCCESS( + f"Stopped {len(scheduled_calls)} scheduled calls for campaign {campaign.id} ({campaign.name})." + ) + ) diff --git a/django_app/callpower/apps/core/management/commands/syncscheduledjobs.py b/django_app/callpower/apps/core/management/commands/syncscheduledjobs.py new file mode 100644 index 00000000..8ab68b42 --- /dev/null +++ b/django_app/callpower/apps/core/management/commands/syncscheduledjobs.py @@ -0,0 +1,26 @@ +from django.core.management.base import BaseCommand + +from callpower.apps.core.models import ScheduleCall, SyncCampaign + + +class Command(BaseCommand): + help = "Backfill Django scheduler metadata from existing scheduled call and sync records." + + def handle(self, *args, **options): + scheduled_call_count = 0 + sync_campaign_count = 0 + + for schedule_call in ScheduleCall.objects.filter(subscribed=True).order_by("id"): + schedule_call.start_job() + scheduled_call_count += 1 + + for sync_campaign in SyncCampaign.objects.exclude(schedule__isnull=True).exclude(schedule="").order_by("id"): + if sync_campaign.has_schedule(): + sync_campaign.start(sync_campaign.schedule) + sync_campaign_count += 1 + + self.stdout.write( + self.style.SUCCESS( + f"Synced {scheduled_call_count} scheduled calls and {sync_campaign_count} CRM sync schedules." + ) + ) diff --git a/django_app/callpower/apps/core/migrations/0001_initial.py b/django_app/callpower/apps/core/migrations/0001_initial.py new file mode 100644 index 00000000..a2d50c31 --- /dev/null +++ b/django_app/callpower/apps/core/migrations/0001_initial.py @@ -0,0 +1,38 @@ +# Generated by Django 5.1.4 on 2026-04-17 19:35 + +from django.db import migrations, models + + +class Migration(migrations.Migration): + + initial = True + + dependencies = [] + + operations = [ + migrations.CreateModel( + name="ScheduledJob", + fields=[ + ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")), + ("job_key", models.CharField(max_length=64, unique=True)), + ( + "kind", + models.CharField( + choices=[("scheduled_call", "Scheduled call"), ("crm_sync", "CRM sync")], + max_length=32, + ), + ), + ("object_id", models.IntegerField()), + ("active", models.BooleanField(default=True)), + ("payload", models.JSONField(blank=True, default=dict)), + ("next_run_at", models.DateTimeField(blank=True, null=True)), + ("last_run_at", models.DateTimeField(blank=True, null=True)), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ], + options={ + "db_table": "django_scheduler_job", + "ordering": ["next_run_at", "id"], + }, + ), + ] diff --git a/django_app/callpower/apps/core/migrations/0002_audiorecording_blocklist_call_campaign_and_more.py b/django_app/callpower/apps/core/migrations/0002_audiorecording_blocklist_call_campaign_and_more.py new file mode 100644 index 00000000..84f24daf --- /dev/null +++ b/django_app/callpower/apps/core/migrations/0002_audiorecording_blocklist_call_campaign_and_more.py @@ -0,0 +1,241 @@ +# Generated by Django 5.1.4 on 2026-04-17 19:37 + +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ('core', '0001_initial'), + ] + + operations = [ + migrations.CreateModel( + name='AudioRecording', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('key', models.CharField(max_length=255)), + ('file_storage', models.CharField(blank=True, max_length=1024, null=True)), + ('text_to_speech', models.TextField(blank=True, null=True)), + ('version', models.IntegerField(blank=True, null=True)), + ('description', models.CharField(blank=True, max_length=255, null=True)), + ('hidden', models.BooleanField(default=False)), + ], + options={ + 'db_table': 'campaign_recording', + 'managed': False, + }, + ), + migrations.CreateModel( + name='Blocklist', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('timestamp', models.DateTimeField(blank=True, null=True)), + ('expires', models.DurationField(blank=True, null=True)), + ('phone_number', models.CharField(blank=True, max_length=64, null=True)), + ('phone_hash', models.CharField(blank=True, max_length=64, null=True)), + ('ip_address', models.CharField(blank=True, max_length=16, null=True)), + ('hits', models.IntegerField(default=0)), + ], + options={ + 'db_table': 'admin_blocklist', + 'managed': False, + }, + ), + migrations.CreateModel( + name='Call', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('timestamp', models.DateTimeField(blank=True, null=True)), + ('call_id', models.CharField(blank=True, max_length=40, null=True)), + ('status', models.CharField(blank=True, max_length=25, null=True)), + ('duration', models.IntegerField(blank=True, null=True)), + ], + options={ + 'db_table': 'calls', + 'ordering': ['-timestamp', '-id'], + 'managed': False, + }, + ), + migrations.CreateModel( + name='Campaign', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('created_time', models.DateTimeField(blank=True, null=True)), + ('name', models.CharField(max_length=500)), + ('country_code', models.CharField(blank=True, max_length=255, null=True)), + ('campaign_type', models.CharField(blank=True, max_length=255, null=True)), + ('campaign_state', models.CharField(blank=True, max_length=255, null=True)), + ('campaign_subtype', models.CharField(blank=True, max_length=255, null=True)), + ('campaign_language', models.CharField(blank=True, max_length=255, null=True)), + ('segment_by', models.CharField(blank=True, max_length=255, null=True)), + ('locate_by', models.CharField(blank=True, max_length=255, null=True)), + ('include_special', models.CharField(blank=True, max_length=255, null=True)), + ('target_ordering', models.CharField(blank=True, max_length=255, null=True)), + ('target_shuffle_chamber', models.BooleanField(default=True)), + ('target_offices', models.CharField(blank=True, max_length=255, null=True)), + ('call_maximum', models.SmallIntegerField(blank=True, null=True)), + ('allow_call_in', models.BooleanField(default=False)), + ('allow_intl_calls', models.BooleanField(default=False)), + ('prompt_schedule', models.BooleanField(default=False)), + ('status_code', models.SmallIntegerField(default=0)), + ('embed', models.JSONField(blank=True, null=True)), + ], + options={ + 'db_table': 'campaign_campaign', + 'ordering': ['-status_code', '-id'], + 'managed': False, + }, + ), + migrations.CreateModel( + name='CampaignAudioRecording', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('selected', models.BooleanField(default=False)), + ], + options={ + 'db_table': 'campaign_audio_recordings', + 'managed': False, + }, + ), + migrations.CreateModel( + name='CampaignPhoneNumber', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ], + options={ + 'db_table': 'campaign_phone_numbers', + 'managed': False, + }, + ), + migrations.CreateModel( + name='CampaignTarget', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('order', models.IntegerField(blank=True, null=True)), + ], + options={ + 'db_table': 'campaign_target_sets', + 'managed': False, + }, + ), + migrations.CreateModel( + name='LegacyUser', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('name', models.CharField(max_length=255)), + ('email', models.CharField(max_length=255)), + ('openid', models.CharField(blank=True, max_length=255, null=True)), + ('activation_key', models.CharField(blank=True, max_length=255, null=True)), + ('created_time', models.DateTimeField(blank=True, null=True)), + ('last_accessed', models.DateTimeField(blank=True, null=True)), + ('phone', models.CharField(blank=True, max_length=64, null=True)), + ('password', models.CharField(max_length=255)), + ('role_code', models.SmallIntegerField(default=1)), + ('status_code', models.SmallIntegerField(default=1)), + ], + options={ + 'db_table': 'user_user', + 'managed': False, + }, + ), + migrations.CreateModel( + name='ScheduleCall', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('created_at', models.DateTimeField(blank=True, null=True)), + ('subscribed', models.BooleanField(default=True)), + ('time_to_call', models.TimeField(blank=True, null=True)), + ('last_called', models.DateTimeField(blank=True, null=True)), + ('num_calls', models.IntegerField(default=0)), + ('phone_number', models.CharField(blank=True, max_length=64, null=True)), + ('job_id', models.CharField(blank=True, max_length=36, null=True)), + ], + options={ + 'db_table': 'schedule_call', + 'managed': False, + }, + ), + migrations.CreateModel( + name='Session', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('timestamp', models.DateTimeField(blank=True, null=True)), + ('phone_hash', models.CharField(blank=True, max_length=64, null=True)), + ('location', models.CharField(blank=True, max_length=255, null=True)), + ('referral_code', models.CharField(blank=True, max_length=64, null=True)), + ('from_number', models.CharField(blank=True, max_length=16, null=True)), + ('twilio_id', models.CharField(blank=True, max_length=40, null=True)), + ('duration', models.IntegerField(blank=True, null=True)), + ('status', models.CharField(blank=True, max_length=25, null=True)), + ('direction', models.CharField(blank=True, max_length=25, null=True)), + ('queue_delay', models.DurationField(blank=True, null=True)), + ], + options={ + 'db_table': 'calls_session', + 'managed': False, + }, + ), + migrations.CreateModel( + name='SyncCampaign', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('job_id', models.CharField(blank=True, max_length=36, null=True)), + ('created_time', models.DateTimeField(blank=True, null=True)), + ('last_sync_time', models.DateTimeField(blank=True, null=True)), + ('schedule', models.CharField(default='hourly', max_length=25)), + ('crm_id', models.CharField(blank=True, max_length=40, null=True)), + ('crm_key', models.CharField(blank=True, max_length=40, null=True)), + ], + options={ + 'db_table': 'sync_campaign', + 'managed': False, + }, + ), + migrations.CreateModel( + name='Target', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('key', models.CharField(blank=True, max_length=255, null=True)), + ('title', models.CharField(blank=True, max_length=255, null=True)), + ('name', models.CharField(max_length=255)), + ('district', models.CharField(blank=True, max_length=255, null=True)), + ('number', models.CharField(blank=True, max_length=64, null=True)), + ('location', models.CharField(blank=True, max_length=255, null=True)), + ], + options={ + 'db_table': 'campaign_target', + 'managed': False, + }, + ), + migrations.CreateModel( + name='TargetOffice', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('uid', models.CharField(blank=True, max_length=255, null=True)), + ('name', models.CharField(blank=True, max_length=255, null=True)), + ('address', models.CharField(blank=True, max_length=255, null=True)), + ('latlon', models.CharField(blank=True, max_length=255, null=True)), + ('type', models.CharField(blank=True, max_length=255, null=True)), + ('number', models.CharField(blank=True, max_length=64, null=True)), + ], + options={ + 'db_table': 'campaign_target_office', + 'managed': False, + }, + ), + migrations.CreateModel( + name='TwilioPhoneNumber', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('twilio_sid', models.CharField(blank=True, max_length=64, null=True)), + ('twilio_app', models.CharField(blank=True, max_length=64, null=True)), + ('call_in_allowed', models.BooleanField(default=False)), + ('number', models.CharField(blank=True, max_length=64, null=True)), + ], + options={ + 'db_table': 'campaign_phone', + 'managed': False, + }, + ), + ] diff --git a/django_app/callpower/apps/core/migrations/0003_synccall.py b/django_app/callpower/apps/core/migrations/0003_synccall.py new file mode 100644 index 00000000..828c6434 --- /dev/null +++ b/django_app/callpower/apps/core/migrations/0003_synccall.py @@ -0,0 +1,27 @@ +# Generated by Django 5.1.4 on 2026-04-17 19:46 + +import django.db.models.deletion +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ('core', '0002_audiorecording_blocklist_call_campaign_and_more'), + ] + + operations = [ + migrations.CreateModel( + name='SyncCall', + fields=[ + ('id', models.AutoField(primary_key=True, serialize=False)), + ('created_time', models.DateTimeField(auto_now_add=True)), + ('saved', models.BooleanField(default=False)), + ('crm_message', models.CharField(blank=True, max_length=255, null=True)), + ('call', models.ForeignKey(db_column='call_id', on_delete=django.db.models.deletion.CASCADE, related_name='sync_records', to='core.call')), + ], + options={ + 'db_table': 'sync_call', + }, + ), + ] diff --git a/django_app/callpower/apps/core/migrations/__init__.py b/django_app/callpower/apps/core/migrations/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/django_app/callpower/apps/core/models.py b/django_app/callpower/apps/core/models.py new file mode 100644 index 00000000..bb39f173 --- /dev/null +++ b/django_app/callpower/apps/core/models.py @@ -0,0 +1,723 @@ +import hashlib +import uuid +from datetime import timedelta + +import phonenumbers +from django.db import models +from django.db.models import Count, Q +from django.utils import timezone +from django.conf import settings +from pathlib import Path +from werkzeug.security import check_password_hash, generate_password_hash + + +USER_ADMIN = 0 +USER_STAFF = 1 +USER_PARTNER = 2 +USER_VIEWER = 3 +USER_ROLE = { + USER_ADMIN: "admin", + USER_STAFF: "staff", + USER_PARTNER: "partner", + USER_VIEWER: "viewer", +} + +USER_INACTIVE = 0 +USER_NEW = 1 +USER_ACTIVE = 2 +USER_STATUS = { + USER_INACTIVE: "inactive", + USER_NEW: "new", + USER_ACTIVE: "active", +} + + +class LegacyUser(models.Model): + id = models.AutoField(primary_key=True) + name = models.CharField(max_length=255) + email = models.CharField(max_length=255) + openid = models.CharField(max_length=255, blank=True, null=True) + activation_key = models.CharField(max_length=255, blank=True, null=True) + created_time = models.DateTimeField(blank=True, null=True) + last_accessed = models.DateTimeField(blank=True, null=True) + phone = models.CharField(max_length=64, blank=True, null=True) + password = models.CharField(max_length=255) + role_code = models.SmallIntegerField(default=1) + status_code = models.SmallIntegerField(default=1) + + class Meta: + db_table = "user_user" + managed = False + + def __str__(self): + return self.name + + @property + def role(self): + return USER_ROLE.get(self.role_code, "unknown") + + @property + def status(self): + return USER_STATUS.get(self.status_code, "unknown") + + def is_admin(self): + return self.role_code == USER_ADMIN + + def is_active_user(self): + return self.status_code == USER_ACTIVE + + def set_password(self, raw_password): + self.password = generate_password_hash(raw_password) + + def check_password(self, raw_password): + if not self.password: + return False + return check_password_hash(self.password, raw_password) + + +class Campaign(models.Model): + id = models.AutoField(primary_key=True) + created_time = models.DateTimeField(blank=True, null=True) + name = models.CharField(max_length=500) + country_code = models.CharField(max_length=255, blank=True, null=True) + campaign_type = models.CharField(max_length=255, blank=True, null=True) + campaign_state = models.CharField(max_length=255, blank=True, null=True) + campaign_subtype = models.CharField(max_length=255, blank=True, null=True) + campaign_language = models.CharField(max_length=255, blank=True, null=True) + segment_by = models.CharField(max_length=255, blank=True, null=True) + locate_by = models.CharField(max_length=255, blank=True, null=True) + include_special = models.CharField(max_length=255, blank=True, null=True) + target_ordering = models.CharField(max_length=255, blank=True, null=True) + target_shuffle_chamber = models.BooleanField(default=True) + target_offices = models.CharField(max_length=255, blank=True, null=True) + call_maximum = models.SmallIntegerField(blank=True, null=True) + allow_call_in = models.BooleanField(default=False) + allow_intl_calls = models.BooleanField(default=False) + prompt_schedule = models.BooleanField(default=False) + status_code = models.SmallIntegerField(default=0) + embed = models.JSONField(blank=True, null=True) + + class Meta: + db_table = "campaign_campaign" + managed = False + ordering = ["-status_code", "-id"] + + def __str__(self): + return self.name + + @property + def completed_calls_count(self): + return getattr(self, "completed_calls", 0) + + @property + def total_sessions_count(self): + return getattr(self, "total_sessions", 0) + + @classmethod + def with_dashboard_counts(cls): + return cls.objects.annotate( + completed_calls=Count( + "call_records", + filter=Q(call_records__status="completed"), + distinct=True, + ), + total_sessions=Count("sessions", distinct=True), + ) + + def _audio_links(self): + return self.campaign_audio_links.select_related("recording").filter(selected=True) + + def audio_or_default(self, key): + campaign_audio = self._audio_links().filter(recording__key=key).first() + if campaign_audio: + return campaign_audio.recording, False + return settings.CAMPAIGN_MESSAGE_DEFAULTS.get(key), True + + def audio(self, key): + return self.audio_or_default(key)[0] + + @property + def language_code(self): + if self.campaign_language and self.country_code: + return f"{self.campaign_language.lower()}-{self.country_code.upper()}" + return "en-US" + + +class Target(models.Model): + id = models.AutoField(primary_key=True) + key = models.CharField(max_length=255, blank=True, null=True) + title = models.CharField(max_length=255, blank=True, null=True) + name = models.CharField(max_length=255) + district = models.CharField(max_length=255, blank=True, null=True) + number = models.CharField(max_length=64, blank=True, null=True) + location = models.CharField(max_length=255, blank=True, null=True) + + class Meta: + db_table = "campaign_target" + managed = False + + def __str__(self): + return self.name + + def full_name(self): + return f"{self.title} {self.name}".strip() + + def phone_number(self): + if not self.number: + return None + try: + parsed = phonenumbers.parse(self.number, None) + return phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164) + except phonenumbers.NumberParseException: + return self.number + + @classmethod + def get_or_create(cls, uid, prefix=None, update_offices=True, commit=True, cache=None): + from callpower.apps.political_data.data_cache import check_political_data_cache + from callpower.apps.political_data.cache import political_data_cache + + resolved_cache = political_data_cache if cache is None else cache + key = f"{prefix}:{uid}" if prefix else uid + target = cls.objects.filter(key=key).order_by("-id").first() + created = False + + data = check_political_data_cache(key, cache=resolved_cache) + offices = data.pop("offices", []) + data.pop("uid", None) + + if not target: + target = cls(**data) + target.key = key + target.save() + created = True + elif data and target.key == data.get("key"): + for attr in ["location", "number"]: + new_value = data.get(attr) + if new_value and getattr(target, attr) != new_value: + setattr(target, attr, new_value) + created = True + if created and commit: + target.save(update_fields=["location", "number"]) + + if offices and update_offices: + existing_offices = {office.uid: office for office in target.offices.all()} + for office_data in offices: + office_uid = office_data.get("uid") + if office_uid in existing_offices: + office = existing_offices[office_uid] + updated_fields = [] + for attr in ["name", "type", "address", "number", "latlon"]: + new_value = office_data.get(attr) + if getattr(office, attr) != new_value: + setattr(office, attr, new_value) + updated_fields.append(attr) + if updated_fields: + office.save(update_fields=updated_fields) + created = True + else: + TargetOffice.objects.create(target=target, **office_data) + created = True + + return target, created + + +class TargetOffice(models.Model): + id = models.AutoField(primary_key=True) + uid = models.CharField(max_length=255, blank=True, null=True) + name = models.CharField(max_length=255, blank=True, null=True) + address = models.CharField(max_length=255, blank=True, null=True) + latlon = models.CharField(max_length=255, blank=True, null=True) + type = models.CharField(max_length=255, blank=True, null=True) + number = models.CharField(max_length=64, blank=True, null=True) + target = models.ForeignKey( + Target, + related_name="offices", + db_column="target_id", + on_delete=models.DO_NOTHING, + blank=True, + null=True, + ) + + class Meta: + db_table = "campaign_target_office" + managed = False + + def phone_number(self): + if not self.number: + return None + try: + parsed = phonenumbers.parse(self.number, None) + return phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164) + except phonenumbers.NumberParseException: + return self.number + + +class AudioRecording(models.Model): + id = models.AutoField(primary_key=True) + key = models.CharField(max_length=255) + file_storage = models.CharField(max_length=1024, blank=True, null=True) + text_to_speech = models.TextField(blank=True, null=True) + version = models.IntegerField(blank=True, null=True) + description = models.CharField(max_length=255, blank=True, null=True) + hidden = models.BooleanField(default=False) + + class Meta: + db_table = "campaign_recording" + managed = False + + def storage_name(self): + if not self.file_storage: + return None + + raw = str(self.file_storage).strip() + if not raw: + return None + + if raw.startswith("http://") or raw.startswith("https://"): + return raw + + media_root = Path(settings.MEDIA_ROOT) + raw_path = Path(raw) + + if raw_path.is_absolute(): + try: + return str(raw_path.relative_to(media_root)).replace("\\", "/") + except ValueError: + return raw_path.name + + if raw.startswith("uploads/"): + return raw[len("uploads/") :] + + if raw.startswith("/uploads/"): + return raw[len("/uploads/") :] + + return raw.lstrip("/") + + def file_url(self): + storage_name = self.storage_name() + if not storage_name: + return None + if storage_name.startswith("http://") or storage_name.startswith("https://"): + return storage_name + return f"{settings.MEDIA_URL.rstrip('/')}/{storage_name.lstrip('/')}" + + +class CampaignAudioRecording(models.Model): + id = models.AutoField(primary_key=True) + campaign = models.ForeignKey( + Campaign, + related_name="campaign_audio_links", + db_column="campaign_id", + on_delete=models.DO_NOTHING, + ) + recording = models.ForeignKey( + AudioRecording, + related_name="campaign_audio_recordings", + db_column="recording_id", + on_delete=models.DO_NOTHING, + ) + selected = models.BooleanField(default=False) + + class Meta: + db_table = "campaign_audio_recordings" + managed = False + + +class CampaignPhoneNumber(models.Model): + id = models.AutoField(primary_key=True) + campaign = models.ForeignKey( + Campaign, + related_name="campaign_phone_links", + db_column="campaign_id", + on_delete=models.DO_NOTHING, + ) + phone = models.ForeignKey( + "TwilioPhoneNumber", + related_name="campaign_links", + db_column="phone_id", + on_delete=models.DO_NOTHING, + ) + + class Meta: + db_table = "campaign_phone_numbers" + managed = False + + +class CampaignTarget(models.Model): + id = models.AutoField(primary_key=True) + campaign = models.ForeignKey( + Campaign, + related_name="campaign_target_links", + db_column="campaign_id", + on_delete=models.DO_NOTHING, + ) + target = models.ForeignKey( + Target, + related_name="campaign_links", + db_column="target_id", + on_delete=models.DO_NOTHING, + ) + order = models.IntegerField(blank=True, null=True) + + class Meta: + db_table = "campaign_target_sets" + managed = False + + +class Session(models.Model): + id = models.AutoField(primary_key=True) + timestamp = models.DateTimeField(blank=True, null=True) + campaign = models.ForeignKey( + Campaign, + related_name="sessions", + db_column="campaign_id", + on_delete=models.DO_NOTHING, + blank=True, + null=True, + ) + phone_hash = models.CharField(max_length=64, blank=True, null=True) + location = models.CharField(max_length=255, blank=True, null=True) + referral_code = models.CharField(max_length=64, blank=True, null=True) + from_number = models.CharField(max_length=16, blank=True, null=True) + twilio_id = models.CharField(max_length=40, blank=True, null=True) + duration = models.IntegerField(blank=True, null=True) + status = models.CharField(max_length=25, blank=True, null=True) + direction = models.CharField(max_length=25, blank=True, null=True) + queue_delay = models.DurationField(blank=True, null=True) + + class Meta: + db_table = "calls_session" + managed = False + + +class Call(models.Model): + id = models.AutoField(primary_key=True) + timestamp = models.DateTimeField(blank=True, null=True) + session = models.ForeignKey( + Session, + related_name="calls", + db_column="session_id", + on_delete=models.DO_NOTHING, + blank=True, + null=True, + ) + campaign = models.ForeignKey( + Campaign, + related_name="call_records", + db_column="campaign_id", + on_delete=models.DO_NOTHING, + blank=True, + null=True, + ) + target = models.ForeignKey( + Target, + related_name="calls", + db_column="target_id", + on_delete=models.DO_NOTHING, + blank=True, + null=True, + ) + call_id = models.CharField(max_length=40, blank=True, null=True) + status = models.CharField(max_length=25, blank=True, null=True) + duration = models.IntegerField(blank=True, null=True) + + class Meta: + db_table = "calls" + managed = False + ordering = ["-timestamp", "-id"] + + +class ScheduleCall(models.Model): + id = models.AutoField(primary_key=True) + created_at = models.DateTimeField(blank=True, null=True) + subscribed = models.BooleanField(default=True) + time_to_call = models.TimeField(blank=True, null=True) + last_called = models.DateTimeField(blank=True, null=True) + num_calls = models.IntegerField(default=0) + campaign = models.ForeignKey( + Campaign, + related_name="scheduled_calls", + db_column="campaign_id", + on_delete=models.DO_NOTHING, + blank=True, + null=True, + ) + phone_number = models.CharField(max_length=64, blank=True, null=True) + job_id = models.CharField(max_length=36, blank=True, null=True) + + class Meta: + db_table = "schedule_call" + managed = False + + def scheduler_job(self): + if not self.job_id: + return None + return ScheduledJob.objects.filter(job_key=self.job_id).first() + + def start_job(self, location=None): + if not self.pk: + self.save() + + now = timezone.now() + job = self.scheduler_job() + if job and location is None: + location = (job.payload or {}).get("location") + + if not self.created_at: + self.created_at = now + if not self.time_to_call: + self.time_to_call = now.time().replace(second=0, microsecond=0) + + if not self.job_id: + self.job_id = str(uuid.uuid4()) + + next_run_at = next_weekday_run(self.time_to_call, now) + job_defaults = { + "kind": ScheduledJob.KIND_SCHEDULED_CALL, + "object_id": self.id, + "active": True, + "payload": {"location": location or ""}, + "next_run_at": next_run_at, + } + ScheduledJob.objects.update_or_create(job_key=self.job_id, defaults=job_defaults) + self.subscribed = True + self.save(update_fields=["created_at", "time_to_call", "job_id", "subscribed"]) + + def stop_job(self): + job = self.scheduler_job() + if job: + job.active = False + job.save(update_fields=["active"]) + self.subscribed = False + self.save(update_fields=["subscribed"]) + + def is_running(self): + job = self.scheduler_job() + return bool(job and job.active) + + +class TwilioPhoneNumber(models.Model): + id = models.AutoField(primary_key=True) + twilio_sid = models.CharField(max_length=64, blank=True, null=True) + twilio_app = models.CharField(max_length=64, blank=True, null=True) + call_in_allowed = models.BooleanField(default=False) + call_in_campaign = models.ForeignKey( + Campaign, + related_name="call_in_numbers", + db_column="call_in_campaign_id", + on_delete=models.DO_NOTHING, + blank=True, + null=True, + ) + number = models.CharField(max_length=64, blank=True, null=True) + + class Meta: + db_table = "campaign_phone" + managed = False + + +class SyncCampaign(models.Model): + id = models.AutoField(primary_key=True) + job_id = models.CharField(max_length=36, blank=True, null=True) + created_time = models.DateTimeField(blank=True, null=True) + last_sync_time = models.DateTimeField(blank=True, null=True) + campaign = models.OneToOneField( + Campaign, + related_name="sync_campaign", + db_column="campaign_id", + on_delete=models.DO_NOTHING, + ) + schedule = models.CharField(max_length=25, default="hourly") + crm_id = models.CharField(max_length=40, blank=True, null=True) + crm_key = models.CharField(max_length=40, blank=True, null=True) + + class Meta: + db_table = "sync_campaign" + managed = False + + def has_schedule(self): + return self.schedule in {"nightly", "hourly", "immediate"} + + def scheduler_job(self): + if not self.job_id: + return None + return ScheduledJob.objects.filter(job_key=self.job_id).first() + + def start(self, schedule=None): + if schedule: + self.schedule = schedule + if not self.pk: + self.save() + if not self.has_schedule(): + return False + + if not self.job_id: + self.job_id = str(uuid.uuid4()) + + now = timezone.now() + job_defaults = { + "kind": ScheduledJob.KIND_CRM_SYNC, + "object_id": self.id, + "active": True, + "payload": {"campaign_id": self.campaign_id}, + "next_run_at": next_sync_run(self.schedule, now), + } + ScheduledJob.objects.update_or_create(job_key=self.job_id, defaults=job_defaults) + self.save(update_fields=["job_id", "schedule"]) + return True + + def stop(self): + job = self.scheduler_job() + if not job: + return False + job.active = False + job.save(update_fields=["active"]) + return True + + def is_running(self): + job = self.scheduler_job() + return bool(job and job.active) + + def sync_calls(self): + from callpower.crm_sync.service import sync_campaign_calls + + return sync_campaign_calls(self) + + +class SyncCall(models.Model): + id = models.AutoField(primary_key=True) + created_time = models.DateTimeField(auto_now_add=True) + call = models.ForeignKey( + Call, + related_name="sync_records", + db_column="call_id", + on_delete=models.CASCADE, + ) + saved = models.BooleanField(default=False) + crm_message = models.CharField(max_length=255, blank=True, null=True) + + class Meta: + db_table = "sync_call" + + +class Blocklist(models.Model): + id = models.AutoField(primary_key=True) + timestamp = models.DateTimeField(blank=True, null=True) + expires = models.DurationField(blank=True, null=True) + phone_number = models.CharField(max_length=64, blank=True, null=True) + phone_hash = models.CharField(max_length=64, blank=True, null=True) + ip_address = models.CharField(max_length=16, blank=True, null=True) + hits = models.IntegerField(default=0) + + class Meta: + db_table = "admin_blocklist" + managed = False + + def save(self, *args, **kwargs): + if not self.timestamp: + self.timestamp = timezone.now() + return super().save(*args, **kwargs) + + def __str__(self): + return self.phone_number or self.phone_hash or self.ip_address or "" + + def is_active(self): + if self.expires and self.timestamp: + timestamp = self.timestamp + if timezone.is_naive(timestamp): + timestamp = timezone.make_aware(timestamp, timezone.utc) + return timezone.now() <= (timestamp + self.expires) + return True + + def match(self, user_phone, user_ip, user_country="US"): + if self.ip_address: + return self.ip_address == user_ip + if self.phone_hash and user_phone: + return self.phone_hash == hashlib.sha256(user_phone.encode("ascii")).hexdigest() + if self.phone_number and user_phone: + try: + stored = phonenumbers.parse(self.phone_number, user_country) + normalized_stored = phonenumbers.format_number(stored, phonenumbers.PhoneNumberFormat.E164) + parsed = phonenumbers.parse(user_phone, user_country) + normalized = phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164) + except phonenumbers.NumberParseException: + normalized_stored = self.phone_number + normalized = user_phone + return normalized_stored == normalized + return False + + @classmethod + def active_blocks(cls): + return [block for block in cls.objects.all() if block.is_active()] + + @classmethod + def user_blocked(cls, user_phone, user_ip, user_country="US"): + active_blocks = cls.active_blocks() + if not active_blocks: + return False + + matched = False + for block in active_blocks: + if block.match(user_phone, user_ip, user_country): + if not block.phone_number and user_phone: + block.phone_number = user_phone + block.hits = (block.hits or 0) + 1 + block.save(update_fields=["phone_number", "hits"]) + matched = True + return matched + + +class ScheduledJob(models.Model): + KIND_SCHEDULED_CALL = "scheduled_call" + KIND_CRM_SYNC = "crm_sync" + + KIND_CHOICES = [ + (KIND_SCHEDULED_CALL, "Scheduled call"), + (KIND_CRM_SYNC, "CRM sync"), + ] + + job_key = models.CharField(max_length=64, unique=True) + kind = models.CharField(max_length=32, choices=KIND_CHOICES) + object_id = models.IntegerField() + active = models.BooleanField(default=True) + payload = models.JSONField(default=dict, blank=True) + next_run_at = models.DateTimeField(blank=True, null=True) + last_run_at = models.DateTimeField(blank=True, null=True) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "django_scheduler_job" + ordering = ["next_run_at", "id"] + + +def next_weekday_run(time_to_call, base_time): + candidate = base_time.replace( + hour=time_to_call.hour, + minute=time_to_call.minute, + second=0, + microsecond=0, + ) + if candidate <= base_time: + candidate += timedelta(days=1) + while candidate.weekday() >= 5: + candidate += timedelta(days=1) + return candidate + + +def next_sync_run(schedule, base_time): + normalized = (schedule or "hourly").lower() + base = base_time.replace(second=0, microsecond=0) + + if normalized == "immediate": + return base + timedelta(minutes=1) + if normalized == "nightly": + candidate = base.replace(hour=23, minute=0) + if candidate <= base: + candidate += timedelta(days=1) + return candidate + + candidate = base.replace(minute=0) + if candidate <= base: + candidate += timedelta(hours=1) + return candidate diff --git a/django_app/callpower/apps/core/scheduler.py b/django_app/callpower/apps/core/scheduler.py new file mode 100644 index 00000000..845a5112 --- /dev/null +++ b/django_app/callpower/apps/core/scheduler.py @@ -0,0 +1,101 @@ +from __future__ import annotations + +import json +from typing import Iterable + +from django.test import RequestFactory +from django.utils import timezone + +from callpower.apps.calls.views import create as create_call_view +from callpower.apps.core.models import ScheduleCall, ScheduledJob, SyncCampaign, next_sync_run, next_weekday_run +from callpower.crm_sync.service import sync_campaign_calls + + +def due_jobs(now=None) -> Iterable[ScheduledJob]: + now = now or timezone.now() + return ScheduledJob.objects.filter(active=True, next_run_at__isnull=False, next_run_at__lte=now).order_by( + "next_run_at", "id" + ) + + +def run_due_jobs(now=None): + now = now or timezone.now() + results = [] + for job in due_jobs(now): + if job.kind == ScheduledJob.KIND_SCHEDULED_CALL: + results.append(run_scheduled_call_job(job, now)) + elif job.kind == ScheduledJob.KIND_CRM_SYNC: + results.append(run_crm_sync_job(job, now)) + return results + + +def run_scheduled_call_job(job, now=None): + now = now or timezone.now() + schedule_call = ScheduleCall.objects.filter(pk=job.object_id).select_related("campaign").first() + if not schedule_call: + job.active = False + job.save(update_fields=["active"]) + return {"job": job.job_key, "kind": job.kind, "status": "missing"} + + if not schedule_call.subscribed: + job.active = False + job.save(update_fields=["active"]) + return {"job": job.job_key, "kind": job.kind, "status": "unsubscribed"} + + campaign = schedule_call.campaign + executed = False + result_payload = {} + + if campaign and campaign.status_code == 2: + factory = RequestFactory() + payload = { + "campaignId": str(campaign.id), + "userPhone": schedule_call.phone_number or "", + "userCountry": (campaign.country_code or "US").upper(), + "userLocation": (job.payload or {}).get("location", ""), + "scheduled": "true", + } + request = factory.post("/call/create", data=payload) + request.META["REMOTE_ADDR"] = "127.0.0.1" + response = create_call_view(request) + try: + result_payload = json.loads(response.content.decode("utf-8")) + except Exception: + result_payload = {"status_code": response.status_code} + if response.status_code == 200 and result_payload.get("call") != "failed": + schedule_call.last_called = now + schedule_call.num_calls = (schedule_call.num_calls or 0) + 1 + schedule_call.save(update_fields=["last_called", "num_calls"]) + executed = True + + schedule_call_time = schedule_call.time_to_call or now.time().replace(second=0, microsecond=0) + job.last_run_at = now + job.next_run_at = next_weekday_run(schedule_call_time, now) + job.save(update_fields=["last_run_at", "next_run_at"]) + return { + "job": job.job_key, + "kind": job.kind, + "status": "executed" if executed else "skipped", + "details": result_payload, + } + + +def run_crm_sync_job(job, now=None): + now = now or timezone.now() + sync_campaign = SyncCampaign.objects.filter(pk=job.object_id).select_related("campaign").first() + if not sync_campaign: + job.active = False + job.save(update_fields=["active"]) + return {"job": job.job_key, "kind": job.kind, "status": "missing"} + + result = sync_campaign_calls(sync_campaign) + + job.last_run_at = now + job.next_run_at = next_sync_run(sync_campaign.schedule, now) + job.save(update_fields=["last_run_at", "next_run_at"]) + return { + "job": job.job_key, + "kind": job.kind, + "status": "executed", + "details": result, + } diff --git a/django_app/callpower/apps/political_data/__init__.py b/django_app/callpower/apps/political_data/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/django_app/callpower/apps/political_data/adapters.py b/django_app/callpower/apps/political_data/adapters.py new file mode 100644 index 00000000..9172edbe --- /dev/null +++ b/django_app/callpower/apps/political_data/adapters.py @@ -0,0 +1,206 @@ +from collections import defaultdict + + +def adapt_by_key(key): + if key.startswith("us:bioguide"): + return UnitedStatesData() + if key.startswith("us_state:openstates"): + return OpenStatesData() + if key.startswith("us_state:governor"): + return GovernorAdapter() + if key.startswith("ca:opennorth"): + return OpenNorthAdapter() + if key.startswith("custom"): + return CustomDataAdapter() + return DataAdapter() + + +class DataAdapter: + def key(self, key, split_by="-"): + return key.split(split_by, 1) if split_by in key else (key, "") + + def target(self, data): + return data + + def offices(self, data): + return [data] + + +class CustomDataAdapter(DataAdapter): + def target(self, data): + adapted = {"title": data.get("title", ""), "uid": data.get("uid", ""), "number": data.get("number", "")} + if "first_name" in data and "last_name" in data: + adapted["name"] = f"{data['first_name']} {data['last_name']}" + else: + adapted["name"] = data.get("name", "Unknown") + return adapted + + +class UnitedStatesData(DataAdapter): + def key(self, key): + return key.split("-", 1) if "-" in key else (key, "") + + def target(self, data): + name = data.get("name") + if isinstance(name, dict): + full_name = name.get("official_full") + else: + full_name = name + adapted = { + "number": data.get("phone", ""), + "title": data.get("title", ""), + "uid": data.get("bioguide_id", ""), + "location": "DC", + "name": full_name or f"{data.get('nick_name') or data.get('first_name', '')} {data.get('last_name', '')}".strip(), + "district": f"{data.get('state', '')}-{data.get('district')}" if data.get("district") else data.get("state", ""), + } + return adapted + + def offices(self, data): + offices = [] + for office in data.get("offices", []): + if "phone" not in office: + continue + entry = { + "name": office.get("city", ""), + "number": office.get("phone", ""), + "uid": office.get("id", ""), + "type": "district", + "address": " ".join(filter(None, [office.get("address"), office.get("building"), office.get("city"), office.get("state")])), + } + if "latitude" in office and "longitude" in office: + entry["latlon"] = f"POINT({office['latitude']}, {office['longitude']})" + offices.append(entry) + return offices + + +class OpenStatesData(DataAdapter): + def target(self, data): + if data.get("leg_id"): + return self.target_legacy(data) + + adapted = {"uid": data.get("id") or data.get("leg_id")} + chamber = data.get("chamber") + if isinstance(chamber, list): + chamber_value = chamber[0]["organization"]["classification"] + district = chamber[0]["post"]["label"] + elif isinstance(chamber, str): + chamber_value = chamber + district = data.get("district", "") + else: + chamber_value = None + district = None + adapted["title"] = data.get("title") or ("Senator" if chamber_value == "upper" else "Representative") + adapted["district"] = district + adapted["name"] = data.get("name") or data.get("full_name") or f"{data.get('givenName', '')} {data.get('familyName', '')}".strip() + if data.get("contactDetails"): + office_phones = [detail for detail in data["contactDetails"] if detail["type"] == "voice"] + for office in office_phones: + if office.get("note") == "Capitol Office": + adapted["number"] = office.get("value", "") + if "number" not in adapted and office_phones: + adapted["number"] = office_phones[0].get("value", "") + return adapted + + def target_legacy(self, data): + adapted = {"uid": data.get("leg_id", "")} + chamber = data.get("chamber") + if data.get("title"): + adapted["title"] = data.get("title") + elif chamber == "upper": + adapted["title"] = "Senator" + else: + adapted["title"] = "Representative" + + adapted["name"] = ( + data.get("full_name") + or data.get("name") + or f"{data.get('first_name', '')} {data.get('last_name', '')}".strip() + ) + + for office in data.get("offices", []): + if office.get("type") == "capitol": + adapted["number"] = office.get("phone", "") + if "number" not in adapted and data.get("offices"): + adapted["number"] = data["offices"][0].get("phone", "") + + district = data.get("district", "") + try: + adapted["district"] = int(str(district)[3:]) + except (TypeError, ValueError): + adapted["district"] = district + return adapted + + def offices(self, data): + if data.get("leg_id"): + return self.offices_legacy(data) + + offices_dict = defaultdict(dict) + for contact in data.get("contactDetails", []): + offices_dict[contact["note"]][contact["type"]] = contact["value"] + offices_dict[contact["note"]]["name"] = contact["note"] + results = [] + for office in offices_dict.values(): + office_name = office.get("name", "").replace("Office", "").replace("office", "") + if "#" in office_name: + office_name = office_name.split("#")[0] + results.append({ + "name": office_name, + "address": office.get("address", ""), + "number": office.get("voice", ""), + "type": office.get("name", ""), + }) + return results + + def offices_legacy(self, data): + offices = [] + for office in data.get("offices", []): + offices.append({ + "name": office.get("name", ""), + "address": office.get("address", ""), + "number": office.get("phone", ""), + "type": office.get("type", ""), + }) + return offices + + +class GovernorAdapter(DataAdapter): + def target(self, data): + return { + "title": data.get("title", ""), + "number": data.get("phone", ""), + "uid": data.get("state", ""), + "district": data.get("state", ""), + "name": data.get("full_name") or f"{data.get('first_name', '')} {data.get('last_name', '')}".strip(), + } + + def offices(self, data): + return [] + + +class OpenNorthAdapter(DataAdapter): + def key(self, key, split_by=None): + return (key, "") + + def target(self, data): + offices = data.get("offices") or [] + legislature_office = [office for office in offices if office["type"] == "legislature"] + return { + "title": data.get("title") or data.get("elected_office", ""), + "uid": data.get("cache_key", ""), + "district": data.get("district_name", ""), + "number": legislature_office[0].get("tel", "") if legislature_office else "", + "name": data.get("full_name") or data.get("name", "Unknown"), + } + + def offices(self, data): + return [ + { + "name": office.get("type", ""), + "address": office.get("postal", ""), + "number": office.get("tel", ""), + "type": office.get("type", ""), + } + for office in data.get("offices", []) + if office.get("type") != "legislature" and "tel" in office + ] diff --git a/django_app/callpower/apps/political_data/apps.py b/django_app/callpower/apps/political_data/apps.py new file mode 100644 index 00000000..115f26b7 --- /dev/null +++ b/django_app/callpower/apps/political_data/apps.py @@ -0,0 +1,6 @@ +from django.apps import AppConfig + + +class PoliticalDataConfig(AppConfig): + default_auto_field = "django.db.models.BigAutoField" + name = "callpower.apps.political_data" diff --git a/django_app/callpower/apps/political_data/cache.py b/django_app/callpower/apps/political_data/cache.py new file mode 100644 index 00000000..b186dc95 --- /dev/null +++ b/django_app/callpower/apps/political_data/cache.py @@ -0,0 +1,32 @@ +from django.core.cache import cache as django_cache + + +class PoliticalDataCache: + def __init__(self): + self._cache = django_cache + self._keys = set() + + def get(self, key, default=None): + value = self._cache.get(key) + return default if value is None else value + + def set(self, key, value): + self._keys.add(key) + self._cache.set(key, value, timeout=None) + + def set_many(self, mapping): + self._keys.update(mapping.keys()) + self._cache.set_many(mapping, timeout=None) + + def search_prefix(self, prefix): + results = [] + for key in sorted(k for k in self._keys if k.startswith(prefix)): + value = self.get(key) + if isinstance(value, list): + results.extend(value) + elif value is not None: + results.append(value) + return results + + +political_data_cache = PoliticalDataCache() diff --git a/django_app/callpower/apps/political_data/constants.py b/django_app/callpower/apps/political_data/constants.py new file mode 100644 index 00000000..1816a522 --- /dev/null +++ b/django_app/callpower/apps/political_data/constants.py @@ -0,0 +1,80 @@ +US_STATES = ( + ("", ""), + ("AL", "Alabama"), + ("AK", "Alaska"), + ("AS", "American Samoa"), + ("AZ", "Arizona"), + ("AR", "Arkansas"), + ("CA", "California"), + ("CO", "Colorado"), + ("CT", "Connecticut"), + ("DE", "Delaware"), + ("DC", "District of Columbia"), + ("FL", "Florida"), + ("GA", "Georgia"), + ("GU", "Guam"), + ("HI", "Hawaii"), + ("ID", "Idaho"), + ("IL", "Illinois"), + ("IN", "Indiana"), + ("IA", "Iowa"), + ("KS", "Kansas"), + ("KY", "Kentucky"), + ("LA", "Louisiana"), + ("ME", "Maine"), + ("MD", "Maryland"), + ("MA", "Massachusetts"), + ("MI", "Michigan"), + ("MN", "Minnesota"), + ("MS", "Mississippi"), + ("MO", "Missouri"), + ("MT", "Montana"), + ("NE", "Nebraska"), + ("NV", "Nevada"), + ("NH", "New Hampshire"), + ("NJ", "New Jersey"), + ("NM", "New Mexico"), + ("NY", "New York"), + ("NC", "North Carolina"), + ("ND", "North Dakota"), + ("MP", "Northern Mariana Islands"), + ("OH", "Ohio"), + ("OK", "Oklahoma"), + ("OR", "Oregon"), + ("PA", "Pennsylvania"), + ("PR", "Puerto Rico"), + ("RI", "Rhode Island"), + ("SC", "South Carolina"), + ("SD", "South Dakota"), + ("TN", "Tennessee"), + ("TX", "Texas"), + ("UT", "Utah"), + ("VT", "Vermont"), + ("VI", "Virgin Islands"), + ("VA", "Virginia"), + ("WA", "Washington"), + ("WV", "West Virginia"), + ("WI", "Wisconsin"), + ("WY", "Wyoming"), +) +US_STATE_ABBR_DICT = {abbr: name for (abbr, name) in US_STATES} +US_STATE_NAME_DICT = {name: abbr for (abbr, name) in US_STATES} + +CA_PROVINCES = ( + ("", ""), + ("AB", "Alberta"), + ("BC", "British Columbia"), + ("MB", "Manitoba"), + ("NB", "New Brunswick"), + ("NL", "Newfoundland and Labrador"), + ("NT", "Northwest Territories"), + ("NS", "Nova Scotia"), + ("NU", "Nunavut"), + ("ON", "Ontario"), + ("PE", "Prince Edward Island"), + ("QC", "Quebec"), + ("SK", "Saskatchewan"), + ("YT", "Yukon"), +) +CA_PROVINCE_ABBR_DICT = {abbr: name for (abbr, name) in CA_PROVINCES} +CA_PROVINCE_NAME_DICT = {name: abbr for (abbr, name) in CA_PROVINCES} diff --git a/django_app/callpower/apps/political_data/data_cache.py b/django_app/callpower/apps/political_data/data_cache.py new file mode 100644 index 00000000..20fcbb61 --- /dev/null +++ b/django_app/callpower/apps/political_data/data_cache.py @@ -0,0 +1,30 @@ +from callpower.apps.political_data.adapters import adapt_by_key +from callpower.apps.political_data.cache import political_data_cache +from callpower.apps.political_data.registry import get_country_data + + +def check_political_data_cache(key, cache=political_data_cache): + adapter = adapt_by_key(key) + adapted_key, _adapter_suffix = adapter.key(key) + cached_obj = cache.get(adapted_key) + + if not cached_obj and adapted_key.startswith("us_state:openstates"): + leg_id = key.split(":")[-1] + leg = get_country_data("us", cache=cache).get_state_legid(leg_id) + leg["cache_key"] = key + cache.set(key, leg) + cached_obj = leg + + if isinstance(cached_obj, list): + data = adapter.target(cached_obj[0]) + offices = adapter.offices(cached_obj[0]) + elif isinstance(cached_obj, dict): + data = adapter.target(cached_obj) + offices = adapter.offices(cached_obj) + else: + data = cached_obj or {} + offices = cached_obj.get("offices", []) if hasattr(cached_obj, "get") else [] + + data["key"] = adapted_key + data["offices"] = offices + return data diff --git a/django_app/callpower/apps/political_data/geocode.py b/django_app/callpower/apps/political_data/geocode.py new file mode 100644 index 00000000..5a968bd3 --- /dev/null +++ b/django_app/callpower/apps/political_data/geocode.py @@ -0,0 +1,190 @@ +import os + +import geopy + +from callpower.apps.political_data.constants import CA_PROVINCE_NAME_DICT, US_STATE_NAME_DICT + + +GOOGLE_SERVICE = "GoogleV3" +SMARTYSTREETS_SERVICE = "LiveAddress" +SMARTYSTEETS_ZIPCODE_SERVICE = "SmartyStreetsUSZipcode" +NOMINATIM_SERVICE = "Nominatim" +LOCAL_USDATA_SERVICE = "LocalUSDataProvider" + + +class Location(geopy.Location): + def __init__(self, *args, **kwargs): + if args and isinstance(args[0], geopy.Location): + self._wrapped_obj = args[0] + else: + super().__init__(*args, **kwargs) + + def __getattr__(self, attr): + if attr in self.__dict__: + return getattr(self, attr) + if "_wrapped_obj" in dir(self) and attr in dir(self._wrapped_obj): + return getattr(self._wrapped_obj, attr) + raise AttributeError(f"Location object has no attribute {attr}") + + def _find_in_raw(self, field): + if not self.raw: + return None + try: + if self.service == GOOGLE_SERVICE: + for component in self.raw["address_components"]: + if field in component["types"]: + return component["short_name"] + return None + if self.service == SMARTYSTREETS_SERVICE: + return self.raw["components"].get(field) + if self.service == SMARTYSTEETS_ZIPCODE_SERVICE: + return self.raw.get(field) + if self.service == NOMINATIM_SERVICE: + return self.raw["address"].get(field) + if self.service == LOCAL_USDATA_SERVICE: + return self.raw.get(field) + return self.raw.get(field) + except KeyError: + return self.raw.get(field) + + @property + def service(self): + return getattr(self, "_service", "UnknownService") + + @service.setter + def service(self, value): + self._service = value + + @property + def state(self): + if self.service == GOOGLE_SERVICE: + return self._find_in_raw("administrative_area_level_1") + if self.service in [SMARTYSTREETS_SERVICE, SMARTYSTEETS_ZIPCODE_SERVICE]: + return self._find_in_raw("state_abbreviation") + if self.service == NOMINATIM_SERVICE: + if self._find_in_raw("country_code") == "us": + return US_STATE_NAME_DICT.get(self._find_in_raw("state")) + if self._find_in_raw("country_code") == "ca": + return CA_PROVINCE_NAME_DICT.get(self._find_in_raw("state")) + return self._find_in_raw("state") + + @property + def latlon(self): + return (self.latitude, self.longitude) + + @property + def postal(self): + if self.service == GOOGLE_SERVICE: + return self._find_in_raw("postal_code") + if self.service == SMARTYSTREETS_SERVICE: + return self._find_in_raw("zipcode") + if self.service == NOMINATIM_SERVICE: + return self._find_in_raw("postcode") + return self._find_in_raw("zipcode") + + +class LocationError(TypeError): + pass + + +class Geocoder: + def __init__(self, api_name=None, api_key=None, country="US"): + if not (api_name or api_key): + api_name = os.environ.get("GEOCODE_PROVIDER", "nominatim").lower() + api_key = os.environ.get("GEOCODE_API_KEY") + + service = geopy.geocoders.get_geocoder_for_service(api_name) + self.country = country + + if api_name == "nominatim": + self.client = service(country_bias=country, timeout=5, user_agent="CallPower") + elif api_name == "liveaddress": + auth_token = os.environ.get("GEOCODE_API_TOKEN") + self.client = service(api_key, auth_token, timeout=3) + self.client_uszipcode = SmartystreetsUSZipcode(api_key, auth_token) + elif api_key: + self.client = service(api_key=api_key, timeout=3) + else: + raise LocationError("configure GEOCODE_PROVIDER and GEOCODE_API_KEY") + + def get_service_name(self): + return self.client.__class__.__name__.split(".")[-1] + + def postal(self, code, country="us", provider=None): + if provider and country == "us": + districts = provider.get_districts(code) + if districts: + location = Location(code, (None, None), districts[0]) + location.service = LOCAL_USDATA_SERVICE + return location + return self.geocode(code, postal_only=True) + + def geocode(self, address, postal_only=False): + service = self.get_service_name() + if not address: + raise LocationError("empty string passed to geocoder") + + try: + if service == GOOGLE_SERVICE: + response = self.client.geocode(address, region=self.country) + elif service == NOMINATIM_SERVICE: + response = self.client.geocode(address, addressdetails=True) + if not response: + return Location() + intermediate = Location(response) + if postal_only or not intermediate.postal: + response = self.client.reverse(intermediate.latlon) + elif service == SMARTYSTREETS_SERVICE: + response = ( + self.client_uszipcode.geocode(address) + if postal_only + else self.client.geocode(address, exactly_one=True) + ) + else: + response = self.client.geocode(address) + + result = Location(response) + result.service = service + if service == SMARTYSTREETS_SERVICE and postal_only: + result.service = SMARTYSTEETS_ZIPCODE_SERVICE + except geopy.exc.GeocoderTimedOut: + result = Location() + result.service = "Timeout" + return result + + def reverse(self, latlon): + if isinstance(latlon, tuple): + lat, lon = latlon + else: + lat, lon = latlon.split(",") + located = Location(self.client.reverse((lat, lon))) + located.service = self.get_service_name() + return located + + +class SmartystreetsUSZipcode(geopy.geocoders.LiveAddress): + def __init__(self, auth_id, auth_token): + super().__init__(auth_id, auth_token) + self.api = "https://us-zipcode.api.smartystreets.com/lookup" + + def _compose_url(self, zipcode): + query = { + "auth-id": self.auth_id, + "auth-token": self.auth_token, + "zipcode": zipcode, + } + return f"{self.api}?{geopy.compat.urlencode(query)}" + + @staticmethod + def _format_structured_address(matches): + if matches.get("zipcodes"): + best_match = matches.get("zipcodes")[0] + else: + return None + latitude = best_match.get("latitude") + longitude = best_match.get("longitude") + return Location( + address=best_match.get("zipcode"), + point=(latitude, longitude) if latitude and longitude else None, + raw=best_match, + ) diff --git a/django_app/callpower/apps/political_data/lookup.py b/django_app/callpower/apps/political_data/lookup.py new file mode 100644 index 00000000..c9061d32 --- /dev/null +++ b/django_app/callpower/apps/political_data/lookup.py @@ -0,0 +1,69 @@ +from collections import OrderedDict +import random + +from callpower.apps.political_data.cache import political_data_cache +from callpower.apps.political_data.registry import get_country_data + + +INCLUDE_SPECIAL_BEFORE = "before" +INCLUDE_SPECIAL_AFTER = "after" +INCLUDE_SPECIAL_ONLY = "only" +INCLUDE_SPECIAL_FIRST = "first" +INCLUDE_SPECIAL_FALLBACK = "fallback" +SEGMENT_BY_LOCATION = "location" + + +def validate_location(location, campaign, cache=political_data_cache): + campaign_data = get_country_data(campaign.country_code, cache=cache).get_campaign_type(campaign.campaign_type) + return campaign_data.data_provider.get_location(campaign.locate_by, location) + + +def locate_targets(location, campaign, skip_special=False, cache=political_data_cache): + if campaign.segment_by and campaign.segment_by != SEGMENT_BY_LOCATION: + return [] + + country_data = get_country_data(campaign.country_code, cache=cache) + campaign_data = country_data.get_campaign_type(campaign.campaign_type) + location_targets = campaign_data.get_targets_for_campaign(location, campaign) + if getattr(campaign, "pk", None): + special_targets = list( + campaign.campaign_target_links.select_related("target").order_by("order", "id").values_list("target__key", flat=True) + ) + else: + special_targets = [] + + if skip_special: + return location_targets + if not special_targets: + return location_targets + if campaign.target_ordering == "shuffle": + random.shuffle(special_targets) + + if campaign.include_special == INCLUDE_SPECIAL_BEFORE: + return list(OrderedDict.fromkeys(special_targets + location_targets)) + if campaign.include_special == INCLUDE_SPECIAL_AFTER: + return list(OrderedDict.fromkeys(location_targets + special_targets)) + if campaign.include_special == INCLUDE_SPECIAL_ONLY: + overlap = [] + for location_target in location_targets: + for special_target in special_targets: + if special_target.startswith(location_target) and special_target not in overlap: + overlap.append(special_target) + if campaign.target_ordering == "shuffle": + random.shuffle(overlap) + return overlap + if campaign.include_special == INCLUDE_SPECIAL_FIRST: + first_targets = [] + for location_target in location_targets: + for special_target in special_targets: + if special_target.startswith(location_target) and special_target not in first_targets: + first_targets.insert(0, special_target) + return list(OrderedDict.fromkeys(first_targets + special_targets)) + if campaign.include_special == INCLUDE_SPECIAL_FALLBACK: + first_targets = [] + for location_target in location_targets: + for special_target in special_targets: + if special_target.startswith(location_target) and special_target not in first_targets: + first_targets.insert(0, special_target) + return first_targets or location_targets + return special_targets diff --git a/django_app/callpower/apps/political_data/providers/__init__.py b/django_app/callpower/apps/political_data/providers/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/django_app/callpower/apps/political_data/providers/base.py b/django_app/callpower/apps/political_data/providers/base.py new file mode 100644 index 00000000..77da409a --- /dev/null +++ b/django_app/callpower/apps/political_data/providers/base.py @@ -0,0 +1,72 @@ +from django.utils.translation import gettext_lazy as _ + + +class DataProvider: + country_name = None + campaign_types = [] + + def __init__(self, cache, **kwargs): + self._cache = cache + + @property + def campaign_type_choices(self): + return [(key, campaign_type.type_name) for key, campaign_type in self.campaign_types] + + def get_campaign_type(self, type_id): + type_class = dict(self.campaign_types).get(type_id) + return type_class(self) + + def cache_get(self, key, default=None): + return self._cache.get(key, default) + + def cache_set(self, key, value): + if hasattr(self._cache, "set"): + self._cache.set(key, value) + else: + self._cache[key] = value + + def cache_set_many(self, mapping): + if hasattr(self._cache, "set_many"): + self._cache.set_many(mapping) + else: + self._cache.update(mapping) + + def cache_search(self, prefix): + if hasattr(self._cache, "search_prefix"): + return self._cache.search_prefix(prefix) + return [value for key, value in self._cache.items() if key.startswith(prefix)] + + +class CampaignType: + type_name = None + subtypes = [] + target_orders = [ + ("in-order", _("In order")), + ("shuffle", _("Shuffle")), + ] + + def __init__(self, data_provider): + self.data_provider = data_provider + + @property + def region_choices(self): + return [] + + @property + def subtype_choices(self): + return CampaignType.subtypes + self.subtypes + + @property + def target_order_choices(self): + return CampaignType.target_orders + self.target_orders + + def get_targets_for_campaign(self, location, campaign): + if isinstance(location, str): + location = self.data_provider.get_location(campaign.locate_by, location) + all_targets = self.all_targets(location, campaign.campaign_state) + return self.sort_targets( + all_targets, + campaign.campaign_subtype, + campaign.target_ordering, + shuffle_chamber=campaign.target_shuffle_chamber, + ) diff --git a/django_app/callpower/apps/political_data/providers/ca.py b/django_app/callpower/apps/political_data/providers/ca.py new file mode 100644 index 00000000..cefbf67f --- /dev/null +++ b/django_app/callpower/apps/political_data/providers/ca.py @@ -0,0 +1,138 @@ +from django.utils.translation import gettext_lazy as _ + +try: + import represent +except ImportError: # pragma: no cover + represent = None + +from callpower.apps.political_data.constants import CA_PROVINCE_ABBR_DICT +from callpower.apps.political_data.geocode import Geocoder, LocationError +from callpower.apps.political_data.providers.base import CampaignType, DataProvider + + +class CACampaignType(CampaignType): + pass + + +class CACampaignType_Local(CACampaignType): + type_name = "Local" + + +class CACampaignType_Custom(CACampaignType): + type_name = "Custom" + + +class CACampaignType_Executive(CACampaignType): + type_name = "Executive" + subtypes = [("exec", _("Prime Minister")), ("office", _("Office"))] + + def all_targets(self, location, campaign_region=None): + return {"exec": self.data_provider.get_executive()} + + def sort_targets(self, targets, subtype, order, shuffle_chamber=False): + return list(targets.get("exec")) + + +class CACampaignType_Parliament(CACampaignType): + type_name = "Parliament" + subtypes = [("lower", _("House of Commons"))] + target_orders = [("lower-first", _("House of Commons"))] + + def all_targets(self, location, campaign_region=None): + return {"lower": self._get_member_of_parliament(location)} + + def sort_targets(self, targets, subtype, order, shuffle_chamber=False): + return list(targets.get("lower")) if subtype == "lower" else [] + + def _get_member_of_parliament(self, location): + reps = self.data_provider.get_representatives(location) + return (rep["cache_key"] for rep in reps if rep["elected_office"].upper() == "MP") + + +class CACampaignType_Province(CACampaignType): + type_name = "Province" + subtypes = [("lower", _("Legislature"))] + target_orders = [("lower-first", _("Legislature"))] + provincial_legislatures = { + "AB": {"body": "alberta-legislature", "office": "MLA"}, + "BC": {"body": "bc-legislature", "office": "MLA"}, + "MB": {"body": "manitoba-legislature", "office": "MLA"}, + "NB": {"body": "new-brunswick-legislature", "office": "MLA"}, + "NL": {"body": "newfoundland-labrador-legislature", "office": "MHA"}, + "NS": {"body": "nova-scotia-legislature", "office": "MLA"}, + "ON": {"body": "ontario-legislature", "office": "MPP"}, + "PE": {"body": "pei-legislature", "office": "MLA"}, + "QC": {"body": "quebec-assemblee-nationale", "office": "MNA"}, + "SK": {"body": "saskatchewan-legislature", "office": "MLA"}, + } + + @property + def region_choices(self): + return {"": "", **{abbr: CA_PROVINCE_ABBR_DICT.get(abbr) for abbr in self.provincial_legislatures}} + + def all_targets(self, location, campaign_region=None): + return {"lower": self._get_province_representative(location, campaign_region)} + + def sort_targets(self, targets, subtype, order, shuffle_chamber=False): + return list(targets.get("lower")) if subtype == "lower" else [] + + def _get_province_representative(self, location, campaign_region=None): + legislature = self.provincial_legislatures.get(campaign_region) + if not legislature: + return [] + reps = self.data_provider.get_representatives(location, legislature["body"]) + return (rep["cache_key"] for rep in reps if rep["elected_office"].upper() == legislature["office"]) + + +class CADataProvider(DataProvider): + country_name = "Canada" + country_code = "ca" + campaign_types = [ + ("executive", CACampaignType_Executive), + ("parliament", CACampaignType_Parliament), + ("province", CACampaignType_Province), + ("local", CACampaignType_Local), + ("custom", CACampaignType_Custom), + ] + KEY_OPENNORTH = "ca:opennorth:{boundary}" + + def __init__(self, cache, **kwargs): + super().__init__(cache, **kwargs) + self._geocoder = Geocoder(country="CA") + + def get_location(self, locate_by, raw): + if locate_by == "postal": + return self._geocoder.postal(raw) + if locate_by == "address": + return self._geocoder.geocode(raw) + if locate_by == "latlon": + return self._geocoder.reverse(raw) + return None + + def load_data(self): + self.cache_set("political_data:ca", ["data sourced from represent.opennorth.ca"]) + return 0 + + def get_executive(self): + return [{"office": "Prime Minister's Office", "number": "16139924211"}] + + def boundary_url_to_key(self, related_url): + boundary = related_url.strip("/").replace("boundaries/", "") + return boundary.replace("/", ":") + + def get_representatives(self, location, body_name="house-of-commons"): + if represent is None: + raise LocationError("represent is not installed") + if not location or not (location.latitude and location.longitude): + raise LocationError("CADataProvider.get_representatives requires location with lat/lon") + point = f"{location.latitude},{location.longitude}" + reps = represent.representative(point=point, repr_set=body_name) + keys = [] + for rep in reps: + boundary_key = self.boundary_url_to_key(rep["related"]["boundary_url"]) + cache_key = self.KEY_OPENNORTH.format(boundary=boundary_key) + rep["boundary_key"] = boundary_key + rep["cache_key"] = cache_key + self.cache_set(cache_key, rep) + keys.append(rep) + return keys diff --git a/django_app/callpower/apps/political_data/providers/eu.py b/django_app/callpower/apps/political_data/providers/eu.py new file mode 100644 index 00000000..87e1a6ee --- /dev/null +++ b/django_app/callpower/apps/political_data/providers/eu.py @@ -0,0 +1,51 @@ +from callpower.apps.political_data.providers.base import CampaignType, DataProvider + + +class EUCampaignType(CampaignType): + pass + + +class EUCampaignType_Custom(EUCampaignType): + type_name = "Custom - MEP" + + +class EUDataProvider(DataProvider): + campaign_types = [("custom", EUCampaignType_Custom)] + + def load_data(self): + return 0 + + +class FRDataProvider(EUDataProvider): + country_name = "France" + country_code = "fr" + + +class DEDataProvider(EUDataProvider): + country_name = "Germany" + country_code = "de" + + +class ESDataProvider(EUDataProvider): + country_name = "Spain" + country_code = "es" + + +class IRDataProvider(EUDataProvider): + country_name = "Ireland" + country_code = "ir" + + +class ITDataProvider(EUDataProvider): + country_name = "Italy" + country_code = "it" + + +class PLDataProvider(EUDataProvider): + country_name = "Poland" + country_code = "pl" + + +class UKDataProvider(EUDataProvider): + country_name = "United Kingdom" + country_code = "uk" diff --git a/django_app/callpower/apps/political_data/providers/us.py b/django_app/callpower/apps/political_data/providers/us.py new file mode 100644 index 00000000..b7bcd9eb --- /dev/null +++ b/django_app/callpower/apps/political_data/providers/us.py @@ -0,0 +1,428 @@ +import collections +import csv +import json +import os +import random +from datetime import datetime +from pathlib import Path + +from django.utils.translation import gettext_lazy as _ +from graphqlclient import GraphQLClient +import yaml + +from callpower.apps.political_data.constants import US_STATES +from callpower.apps.political_data.geocode import Geocoder, LocationError +from callpower.apps.political_data.providers.base import CampaignType, DataProvider + + +DATA_DIR = Path(__file__).resolve().parents[5] / "call_server" / "political_data" / "data" + + +def ocd_field(ocd_data, field): + for part in ocd_data.split("/"): + if ":" in part: + label, value = part.split(":") + if label == field: + return value + return "" + + +class USCampaignType(CampaignType): + pass + + +class USCampaignType_Local(USCampaignType): + type_name = "Local" + + +class USCampaignType_Custom(USCampaignType): + type_name = "Custom" + + +class USCampaignType_Executive(USCampaignType): + type_name = "Executive" + subtypes = [("exec", _("President")), ("office", _("Office"))] + + def all_targets(self, location, campaign_region=None): + return {"exec": self.data_provider.get_executive()} + + def sort_targets(self, targets, subtype, order, shuffle_chamber=True): + return list(targets.get("exec")) + + +class USCampaignType_Congress(USCampaignType): + type_name = "Congress" + subtypes = [("both", _("Both Bodies")), ("upper", _("Senate")), ("lower", _("House"))] + target_orders = [ + ("shuffle", _("Shuffle")), + ("upper-first", _("Senate First")), + ("lower-first", _("House First")), + ("democrats-first", _("Democrats First")), + ("republicans-first", _("Republicans First")), + ("democrats-only", _("Democrats Only")), + ("republicans-only", _("Republicans Only")), + ] + + @property + def region_choices(self): + return US_STATES + + def all_targets(self, location, campaign_region=None): + return { + "upper": { + "all": self._get_senators(location), + "democrats": self._get_senate_party(location, "Democrat"), + "republicans": self._get_senate_party(location, "Republican"), + }, + "lower": { + "all": self._get_representative(location), + "democrats": self._get_congress_party(location, "Democrat"), + "republicans": self._get_congress_party(location, "Republican"), + }, + } + + def sort_targets(self, targets, subtype, order, shuffle_chamber=True): + upper_targets = list(targets.get("upper").get("all")) + lower_targets = list(targets.get("lower").get("all")) + democrats_upper = list(targets.get("upper").get("democrats")) + republicans_upper = list(targets.get("upper").get("republicans")) + democrats_lower = list(targets.get("lower").get("democrats")) + republicans_lower = list(targets.get("lower").get("republicans")) + democrat_targets = democrats_upper + democrats_lower + republican_targets = republicans_upper + republicans_lower + + if shuffle_chamber: + random.shuffle(upper_targets) + random.shuffle(lower_targets) + + if subtype == "both": + if order == "upper-first": + return upper_targets + lower_targets + if order == "democrats-first": + return democrat_targets + republican_targets + if order == "republicans-first": + return republican_targets + democrat_targets + if order == "democrats-only": + return democrat_targets + if order == "republicans-only": + return republican_targets + return lower_targets + upper_targets + if subtype == "upper": + if order == "democrats-first": + return democrats_upper + republicans_upper + if order == "republicans-first": + return republicans_upper + democrats_upper + if order == "democrats-only": + return democrats_upper + if order == "republicans-only": + return republicans_upper + return upper_targets + if subtype == "lower": + return lower_targets + return [] + + def _get_senators(self, location): + districts = self.data_provider.get_districts(location.postal) + states = set(d["state"] for d in districts) + for state in states: + for senator in self.data_provider.get_senators(state): + yield self.data_provider.KEY_BIOGUIDE.format(**senator) + + def _get_representative(self, location): + for district in self.data_provider.get_districts(location.postal): + rep = self.data_provider.get_house_members(district["state"], district["house_district"]) + if rep: + yield self.data_provider.KEY_BIOGUIDE.format(**rep[0]) + + def _get_senate_party(self, location, party): + matched = [] + districts = self.data_provider.get_districts(location.postal) + states = set(d["state"] for d in districts) + for state in states: + for senator in self.data_provider.get_senators(state): + if senator.get("party") == party: + matched.append(self.data_provider.KEY_BIOGUIDE.format(**senator)) + return matched + + def _get_congress_party(self, location, party): + matched = [] + for district in self.data_provider.get_districts(location.postal): + rep = self.data_provider.get_house_members(district["state"], district["house_district"]) + if rep and rep[0].get("party") == party: + matched.append(self.data_provider.KEY_BIOGUIDE.format(**rep[0])) + return matched + + +class USCampaignType_State(USCampaignType): + type_name = "State" + subtypes = [ + ("exec", _("Governor")), + ("both", _("Legislature - Both Bodies")), + ("upper", _("Legislature - Upper Body")), + ("lower", _("Legislature - Lower Body")), + ] + target_orders = [ + ("shuffle", _("Shuffle")), + ("upper-first", _("Upper First")), + ("lower-first", _("Lower First")), + ] + + @property + def region_choices(self): + return US_STATES + + def all_targets(self, location, campaign_region=None): + upper = "upper" + lower = "lower" + if location.state == "NE": + upper = None + lower = "legislature" + return { + "exec": self._get_state_governor(location, campaign_region), + "upper": self._get_state_legislators(location, campaign_region, upper), + "lower": self._get_state_legislators(location, campaign_region, lower), + } + + def sort_targets(self, targets, subtype, order, shuffle_chamber=True): + upper_targets = list(targets.get("upper")) + lower_targets = list(targets.get("lower")) + exec_targets = list(targets.get("exec")) + if shuffle_chamber: + random.shuffle(upper_targets) + random.shuffle(lower_targets) + if subtype == "both": + return upper_targets + lower_targets if order == "upper-first" else lower_targets + upper_targets + if subtype == "upper": + return upper_targets + if subtype == "lower": + return lower_targets + if subtype == "exec": + return exec_targets + return [] + + def _get_state_governor(self, location, campaign_region=None): + return [self.data_provider.KEY_GOVERNOR.format(state=location.state)] + + def _get_state_legislators(self, location, campaign_region=None, chamber_name="upper"): + legislators = self.data_provider.get_state_legislators(location) + return ( + legislator["cache_key"] + for legislator in legislators + if legislator["chamber"] == chamber_name + and (campaign_region is None or legislator["state"].upper() == campaign_region.upper()) + ) + + +class USDataProvider(DataProvider): + country_name = "United States" + country_code = "us" + campaign_types = [ + ("executive", USCampaignType_Executive), + ("congress", USCampaignType_Congress), + ("state", USCampaignType_State), + ("local", USCampaignType_Local), + ("custom", USCampaignType_Custom), + ] + + KEY_BIOGUIDE = "us:bioguide:{bioguide_id}" + KEY_HOUSE = "us:house:{state}:{district}" + KEY_SENATE = "us:senate:{state}" + KEY_OPENSTATES = "us_state:openstates:{id}" + KEY_GOVERNOR = "us_state:governor:{state}" + KEY_ZIPCODE = "us:zipcode:{zipcode}" + + def __init__(self, cache, **kwargs): + super().__init__(cache, **kwargs) + self._geocoder = Geocoder(country="US") + self._openstates = GraphQLClient("https://openstates.org/graphql") + api_key = os.environ.get("OPENSTATES_API_KEY") + if api_key: + self._openstates.inject_token(api_key, "x-api-key") + + def get_location(self, locate_by, raw, ignore_local_cache=False): + if locate_by == "postal": + return self._geocoder.postal(raw, provider=None if ignore_local_cache else self) + if locate_by == "address": + return self._geocoder.geocode(raw) + if locate_by == "latlon": + return self._geocoder.reverse(raw) + return None + + def _load_districts(self): + districts = collections.defaultdict(list) + with open(DATA_DIR / "us_districts.csv") as handle: + reader = csv.DictReader(handle) + for row in reader: + record = { + "state": row["state_abbr"], + "zipcode": row["zcta"], + "house_district": row["cd"], + } + districts[self.KEY_ZIPCODE.format(**record)].append(record) + return districts + + def _load_governors(self): + governors = collections.defaultdict(list) + with open(DATA_DIR / "us_governors.csv") as handle: + reader = csv.DictReader(handle) + for row in reader: + key = self.KEY_GOVERNOR.format(state=row["state_abbr"]) + governors[key] = [{ + "title": "Governor", + "first_name": row.get("first_name"), + "last_name": row.get("last_name"), + "phone": row.get("phone"), + "state": row.get("state_abbr"), + "state_name": row.get("state_name"), + }] + return governors + + def _load_legislators(self): + legislators = collections.defaultdict(list) + offices = collections.defaultdict(list) + with open(DATA_DIR / "us_congress_current.yaml") as current_handle, \ + open(DATA_DIR / "us_congress_historical.yaml") as historical_handle, \ + open(DATA_DIR / "us_congress_offices.yaml") as offices_handle: + current_leg = yaml.safe_load(current_handle) + historical_leg = yaml.safe_load(historical_handle) + office_info = yaml.safe_load(offices_handle) + + for info in office_info: + bioguide_id = info["id"]["bioguide"] + offices[bioguide_id] = info.get("offices", []) + + for info in current_leg + historical_leg: + term = info["terms"][-1] + if term["start"] < "2015-01-01": + continue + term["current"] = term["end"] >= datetime.now().strftime("%Y-%m-%d") + if term.get("phone") is None and not term["current"]: + continue + district = str(term["district"]) if "district" in term else None + bioguide = info.get("id", {}).get("bioguide", "") + record = { + "first_name": info["name"]["first"], + "last_name": info["name"]["last"], + "bioguide_id": bioguide, + "title": "Senator" if term["type"] == "sen" else "Representative", + "phone": term.get("phone"), + "chamber": "senate" if term["type"] == "sen" else "house", + "state": term["state"], + "district": district, + "offices": offices.get(bioguide, []), + "current": term["current"], + "party": term.get("caucus") or term.get("party"), + } + if info["name"].get("nickname"): + record["nick_name"] = info["name"]["nickname"] + direct_key = self.KEY_BIOGUIDE.format(**record) + chamber_key = self.KEY_SENATE.format(**record) if record["chamber"] == "senate" else self.KEY_HOUSE.format(**record) + legislators[direct_key].append(record) + if term["current"]: + legislators[chamber_key].append(record) + return legislators + + def load_data(self): + districts = self._load_districts() + legislators = self._load_legislators() + governors = self._load_governors() + self.cache_set_many(districts) + self.cache_set_many(legislators) + self.cache_set_many(governors) + self.cache_set("political_data:us", [ + f"{len(districts)} zipcodes", + f"{len(legislators)} legislators", + f"{len(governors)} governors", + ]) + return len(districts) + len(legislators) + len(governors) + + def get_executive(self): + return [{"office": "Whitehouse Switchboard", "number": "12024561414"}] + + def get_house_members(self, state, district): + return self.cache_get(self.KEY_HOUSE.format(state=state, district=district), []) + + def get_senators(self, state): + return self.cache_get(self.KEY_SENATE.format(state=state), []) + + def get_districts(self, zipcode): + return self.cache_get(self.KEY_ZIPCODE.format(zipcode=zipcode), []) + + def get_state_governor(self, state): + return self.cache_get(self.KEY_GOVERNOR.format(state=state), []) + + def get_uid(self, uid): + return self.cache_get(uid, {}) + + def get_state_legislators(self, location): + if not (location.latitude and location.longitude): + location = self.get_location("postal", location.raw, ignore_local_cache=True) + if not (location.latitude and location.longitude): + raise LocationError("USDataProvider.get_state_legislators requires location with lat/lon") + api_response = self._openstates.execute( + """ + { people(latitude: %f, longitude: %f, first: 100) { + edges { + node { + id + name + givenName + familyName + chamber: currentMemberships(classification:["upper", "lower", "legislature"]) { + post { label role division { id } } + organization { name classification jurisdictionId } + } + contactDetails { value note type } + } + } + } + }""" + % (location.latitude, location.longitude) + ) + parsed = json.loads(api_response) + legislators = [] + for edge in parsed["data"]["people"]["edges"]: + legislator = edge["node"] + legislator["chamber"] = legislator["chamber"][0]["organization"]["classification"] + legislator["district"] = legislator["chamber"][0]["post"]["label"] + division = legislator["chamber"][0]["post"]["division"]["id"] + legislator["state"] = ocd_field(division, "state").upper() + legislator["title"] = legislator["chamber"][0]["post"]["role"] + if not ocd_field(legislator["chamber"][0]["organization"]["jurisdictionId"], "state"): + continue + key = self.KEY_OPENSTATES.format(id=legislator["id"]) + legislator["cache_key"] = key + self.cache_set(key, legislator) + legislators.append(legislator) + return legislators + + def get_state_legid(self, ocd_id): + key = self.KEY_OPENSTATES.format(id=ocd_id) + legislator = self.cache_get(key) + if legislator: + return legislator + api_response = self._openstates.execute( + """{ + person(id:"%s") { + id + name + givenName + familyName + chamber: currentMemberships(classification:["upper", "lower", "legislature"]) { + post { label role division { id } } + organization { name classification } + } + contactDetails { value note type } + } + }""" + % ocd_id + ) + legislator = json.loads(api_response)["data"]["person"] + legislator["chamber"] = legislator["chamber"][0]["organization"]["classification"] + legislator["district"] = legislator["chamber"][0]["post"]["label"] + division = legislator["chamber"][0]["post"]["division"]["id"] + legislator["state"] = ocd_field(division, "state").upper() + legislator["title"] = legislator["chamber"][0]["post"]["role"] + legislator["cache_key"] = key + self.cache_set(key, legislator) + return legislator diff --git a/django_app/callpower/apps/political_data/registry.py b/django_app/callpower/apps/political_data/registry.py new file mode 100644 index 00000000..22e36c30 --- /dev/null +++ b/django_app/callpower/apps/political_data/registry.py @@ -0,0 +1,42 @@ +from importlib import import_module + +from callpower.apps.political_data.cache import political_data_cache + + +COUNTRY_CHOICES = [ + ("us", "United States"), + ("ca", "Canada"), + ("fr", "France"), + ("de", "Germany"), + ("es", "Spain"), + ("ir", "Ireland"), + ("it", "Italy"), + ("pl", "Poland"), + ("uk", "United Kingdom"), +] + +COUNTRY_DATA = { + "us": "callpower.apps.political_data.providers.us.USDataProvider", + "ca": "callpower.apps.political_data.providers.ca.CADataProvider", + "fr": "callpower.apps.political_data.providers.eu.FRDataProvider", + "de": "callpower.apps.political_data.providers.eu.DEDataProvider", + "es": "callpower.apps.political_data.providers.eu.ESDataProvider", + "ir": "callpower.apps.political_data.providers.eu.IRDataProvider", + "it": "callpower.apps.political_data.providers.eu.ITDataProvider", + "pl": "callpower.apps.political_data.providers.eu.PLDataProvider", + "uk": "callpower.apps.political_data.providers.eu.UKDataProvider", +} + + +def get_country_data(country_code, cache=political_data_cache): + module_name, class_name = COUNTRY_DATA[country_code.lower()].rsplit(".", 1) + provider_class = getattr(import_module(module_name), class_name) + provider = provider_class(cache=cache) + ensure_loaded(country_code.lower(), provider) + return provider + + +def ensure_loaded(country_code, provider): + marker = f"political_data:{country_code.lower()}" + if provider.cache_get(marker) is None: + provider.load_data() diff --git a/django_app/callpower/apps/political_data/services.py b/django_app/callpower/apps/political_data/services.py new file mode 100644 index 00000000..445a4805 --- /dev/null +++ b/django_app/callpower/apps/political_data/services.py @@ -0,0 +1,32 @@ +from django.db import transaction + +from callpower.apps.core.models import Target, TargetOffice +from callpower.apps.political_data.data_cache import check_political_data_cache + + +@transaction.atomic +def ensure_target_from_key(key): + existing = Target.objects.filter(key=key).order_by("-id").first() + data = check_political_data_cache(key) + offices = data.pop("offices", []) + data.pop("uid", None) + + if not existing: + target = Target.objects.create(key=key, **data) + else: + target = existing + for field, value in data.items(): + setattr(target, field, value) + target.save() + + existing_uids = {office.uid for office in target.offices.all()} + for office_data in offices: + office_uid = office_data.get("uid") + if office_uid in existing_uids: + office = target.offices.filter(uid=office_uid).first() + for field, value in office_data.items(): + setattr(office, field, value) + office.save() + else: + TargetOffice.objects.create(target=target, **office_data) + return target diff --git a/django_app/callpower/apps/political_data/urls.py b/django_app/callpower/apps/political_data/urls.py new file mode 100644 index 00000000..b1a81727 --- /dev/null +++ b/django_app/callpower/apps/political_data/urls.py @@ -0,0 +1,8 @@ +from django.urls import path + +from callpower.apps.political_data import views + + +urlpatterns = [ + path("search", views.search, name="political-data-search"), +] diff --git a/django_app/callpower/apps/political_data/views.py b/django_app/callpower/apps/political_data/views.py new file mode 100644 index 00000000..61c62b2b --- /dev/null +++ b/django_app/callpower/apps/political_data/views.py @@ -0,0 +1,17 @@ +from django.http import JsonResponse +from django.views.decorators.http import require_GET + +from callpower.apps.political_data.registry import get_country_data + + +@require_GET +def search(request): + country = request.GET.get("country", "us") + keys = request.GET.getlist("key") + if not keys: + return JsonResponse({"status": "error", "message": "no key provided"}, status=400) + data_provider = get_country_data(country) + results = [] + for key in keys: + results.extend(data_provider.cache_search(key)) + return JsonResponse({"status": "ok", "results": results}) diff --git a/django_app/callpower/apps/public/__init__.py b/django_app/callpower/apps/public/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/django_app/callpower/apps/public/__init__.py @@ -0,0 +1 @@ + diff --git a/django_app/callpower/apps/public/apps.py b/django_app/callpower/apps/public/apps.py new file mode 100644 index 00000000..0f80c293 --- /dev/null +++ b/django_app/callpower/apps/public/apps.py @@ -0,0 +1,7 @@ +from django.apps import AppConfig + + +class PublicConfig(AppConfig): + default_auto_field = "django.db.models.BigAutoField" + name = "callpower.apps.public" + label = "callpower_public" diff --git a/django_app/callpower/apps/public/urls.py b/django_app/callpower/apps/public/urls.py new file mode 100644 index 00000000..406b24da --- /dev/null +++ b/django_app/callpower/apps/public/urls.py @@ -0,0 +1,29 @@ +from django.urls import path + +from callpower.apps.public import views + + +urlpatterns = [ + path("", views.index, name="site-index"), + path("create", views.legacy_call_redirect, name="site-create"), + path("incoming_call", views.legacy_call_incoming, name="site-incoming-call"), + path("call_complete_status", views.legacy_call_status, name="site-call-complete-status"), + path("campaign//", views.campaign_page, name="public-campaign-page"), + path("api/campaign//embed.js", views.campaign_embed_js, name="campaign-embed-js"), + path( + "api/campaign//CallPowerForm.js", + views.campaign_form_js, + name="campaign-form-js", + ), + path( + "api/campaign//embed_iframe.html", + views.campaign_embed_iframe, + name="campaign-embed-iframe", + ), + path( + "api/campaign//embed_code.html", + views.campaign_embed_code, + name="campaign-embed-code", + ), + path("api/campaign//count.json", views.campaign_count, name="campaign-count"), +] diff --git a/django_app/callpower/apps/public/views.py b/django_app/callpower/apps/public/views.py new file mode 100644 index 00000000..9bbc018e --- /dev/null +++ b/django_app/callpower/apps/public/views.py @@ -0,0 +1,134 @@ +from copy import deepcopy + +from django.conf import settings +from django.http import Http404, HttpResponse, JsonResponse +from django.shortcuts import render +from django.views.decorators.cache import cache_page +from django.views.decorators.clickjacking import xframe_options_exempt +from django.views.decorators.csrf import csrf_exempt +from django.views.decorators.http import require_GET, require_http_methods + +from callpower.apps.calls import views as call_views +from callpower.apps.core.models import Call, Campaign + + +def _campaign_or_404(campaign_id): + campaign = Campaign.objects.filter(pk=campaign_id).first() + if not campaign: + raise Http404("Campaign not found") + return campaign + + +def _installed_org(): + return getattr(settings, "INSTALLED_ORG", "OpenSourceActivism.tech") + + +def _base_url(request): + return request.build_absolute_uri("/").rstrip("/") + + +def _embed_context(request, campaign): + return { + "campaign": campaign, + "dsn_public_key": getattr(settings, "SENTRY_DSN_PUBLIC_KEY", ""), + "base_url": _base_url(request), + } + + +def index(request): + return render( + request, + "public/index.html", + { + "installed_org": _installed_org(), + }, + ) + + +@require_GET +def campaign_page(request, campaign_id): + campaign = _campaign_or_404(campaign_id) + return render( + request, + "public/campaign_page.html", + { + "campaign": campaign, + "standalone": True, + "base_url": _base_url(request), + }, + ) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def legacy_call_redirect(request): + return call_views.create(request) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def legacy_call_incoming(request): + return call_views.incoming(request) + + +@csrf_exempt +@require_http_methods(["GET", "POST"]) +def legacy_call_status(request): + return call_views.status_callback(request) + + +@require_GET +@cache_page(60 * 10) +def campaign_embed_js(request, campaign_id): + campaign = _campaign_or_404(campaign_id) + content = render(request, "public/embed.js", _embed_context(request, campaign)).content + return HttpResponse(content, content_type="application/javascript") + + +@require_GET +@cache_page(60 * 10) +def campaign_form_js(request, campaign_id): + campaign = _campaign_or_404(campaign_id) + content = render( + request, + "public/CallPowerForm.js", + {"campaign": campaign, "base_url": _base_url(request)}, + ).content + return HttpResponse(content, content_type="application/javascript") + + +@require_GET +@cache_page(60 * 10) +@xframe_options_exempt +def campaign_embed_iframe(request, campaign_id): + campaign = _campaign_or_404(campaign_id) + return render(request, "public/embed_iframe.html", {"campaign": campaign, "base_url": _base_url(request)}) + + +@require_GET +def campaign_embed_code(request, campaign_id): + campaign = _campaign_or_404(campaign_id) + embed = deepcopy(campaign.embed or {}) + temp_params = { + "type": request.GET.get("embed_type", embed.get("type", "")), + "form_sel": request.GET.get("embed_form_sel") or embed.get("form_sel"), + "phone_sel": request.GET.get("embed_phone_sel") or embed.get("phone_sel"), + "location_sel": request.GET.get("embed_location_sel") or embed.get("location_sel"), + "custom_css": request.GET.get("embed_custom_css") or embed.get("custom_css"), + "custom_js": request.GET.get("embed_custom_js") or embed.get("custom_js"), + "custom_onload": request.GET.get("embed_custom_onload") or embed.get("custom_onload"), + "script_display": request.GET.get("embed_script_display") or embed.get("script_display"), + "phone_display": request.GET.get("embed_phone_display") or embed.get("phone_display"), + "redirect": request.GET.get("embed_redirect") or embed.get("redirect"), + "script": request.GET.get("embed_script") or embed.get("script", ""), + } + campaign.embed = temp_params + return render(request, "public/embed_code.html", {"campaign": campaign, "base_url": _base_url(request)}) + + +@require_GET +@cache_page(60 * 10) +def campaign_count(request, campaign_id): + campaign = _campaign_or_404(campaign_id) + count = Call.objects.filter(campaign=campaign, status="completed").count() + return JsonResponse({"count": count, "campaignId": campaign.id}) diff --git a/django_app/callpower/auth_backends.py b/django_app/callpower/auth_backends.py new file mode 100644 index 00000000..ed07708e --- /dev/null +++ b/django_app/callpower/auth_backends.py @@ -0,0 +1,44 @@ +from django.contrib.auth.backends import BaseBackend +from django.contrib.auth.models import User +from werkzeug.security import check_password_hash + +from callpower.apps.core.models import LegacyUser + + +class LegacyUserBackend(BaseBackend): + def authenticate(self, request, username=None, password=None, **kwargs): + login = username or kwargs.get("login") + if not login or not password: + return None + + legacy_user = ( + LegacyUser.objects.filter(name__iexact=login).first() + or LegacyUser.objects.filter(email__iexact=login).first() + ) + if not legacy_user: + return None + if legacy_user.status_code != 2: + return None + if not check_password_hash(legacy_user.password, password): + return None + + django_user = User.objects.filter(username=f"legacy-{legacy_user.id}").first() + if not django_user: + django_user = User(username=f"legacy-{legacy_user.id}") + django_user.email = legacy_user.email or "" + django_user.is_active = True + django_user.is_staff = legacy_user.role_code in (0, 1) + django_user.is_superuser = legacy_user.role_code == 0 + django_user.set_unusable_password() + django_user.save() + + if request is not None: + request.session["legacy_user_id"] = legacy_user.id + request.session["legacy_role_code"] = legacy_user.role_code + return django_user + + def get_user(self, user_id): + try: + return User.objects.get(pk=user_id) + except User.DoesNotExist: + return None diff --git a/django_app/callpower/crm_sync/__init__.py b/django_app/callpower/crm_sync/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/django_app/callpower/crm_sync/__init__.py @@ -0,0 +1 @@ + diff --git a/django_app/callpower/crm_sync/integrations/__init__.py b/django_app/callpower/crm_sync/integrations/__init__.py new file mode 100644 index 00000000..84df0061 --- /dev/null +++ b/django_app/callpower/crm_sync/integrations/__init__.py @@ -0,0 +1,40 @@ +from django.conf import settings + +from callpower.crm_sync.integrations.base import CRMIntegrationError + + +def get_crm_integration(): + integration_name = (settings.CRM_INTEGRATION or "").strip().lower() + if not integration_name: + raise CRMIntegrationError("no CRM_INTEGRATION configured") + + if integration_name == "actionkit": + from callpower.crm_sync.integrations.actionkit import ActionKitIntegration + + return ActionKitIntegration( + domain=settings.ACTIONKIT_DOMAIN, + username=settings.ACTIONKIT_USER, + api_key=settings.ACTIONKIT_API_KEY, + password=settings.ACTIONKIT_PASSWORD, + ) + + if integration_name == "rogue": + from callpower.crm_sync.integrations.rogue import RogueIntegration + + return RogueIntegration(domain=settings.ROGUE_DOMAIN, api_key=settings.ROGUE_API_KEY) + + if integration_name == "mobilecommons": + from callpower.crm_sync.integrations.mobilecommons import MobileCommonsIntegration + + return MobileCommonsIntegration( + username=settings.MOBILE_COMMONS_USERNAME, + password=settings.MOBILE_COMMONS_PASSWORD, + company=settings.MOBILE_COMMONS_COMPANY, + ) + + if integration_name == "noop": + from callpower.crm_sync.integrations.noop import NoOpIntegration + + return NoOpIntegration(default_phone=settings.CRM_DEBUG_PHONE) + + raise CRMIntegrationError(f"unknown CRM_INTEGRATION '{settings.CRM_INTEGRATION}'") diff --git a/django_app/callpower/crm_sync/integrations/actionkit.py b/django_app/callpower/crm_sync/integrations/actionkit.py new file mode 100644 index 00000000..c57f5664 --- /dev/null +++ b/django_app/callpower/crm_sync/integrations/actionkit.py @@ -0,0 +1,91 @@ +import phonenumbers + +from callpower.crm_sync.integrations.base import CRMIntegration + + +class ActionKitIntegration(CRMIntegration): + def __init__(self, domain, username, api_key=None, password=None): + try: + from actionkit.rest import ActionKit + from actionkit.xmlrpc import ActionKitXML + except ImportError as exc: + raise ImportError("python-actionkit is required for CRM_INTEGRATION=actionkit") from exc + + if not domain or not username or not (api_key or password): + raise ValueError("ActionKit credentials are incomplete") + + super().__init__() + if api_key: + self.ak_client = ActionKit(instance=domain, username=username, api_key=api_key) + self.ak_rpc = ActionKitXML(instance=domain, username=username, api_key=api_key) + else: + self.ak_client = ActionKit(instance=domain, username=username, password=password) + self.ak_rpc = ActionKitXML(instance=domain, username=username, password=password) + + def get_user(self, phone_number): + normalized_phone = phonenumbers.parse(phone_number).national_number + matching_users = self.ak_client.phone.list(normalized_phone=normalized_phone)["objects"] + if not matching_users: + return None + user_url = matching_users[0]["user"] + ak_user = self.ak_client.get(user_url) + ak_user["phone"] = str(normalized_phone) + return ak_user + + def _match_target_data(self, call): + campaign = call.campaign + target = call.target + target_type = "other" + target_state = "" + if campaign.country_code and campaign.country_code.upper() == "US": + if campaign.campaign_type == "congress": + target_state = (target.location or "").split()[-1] if target and target.location else "" + if target and target.title == "Senator": + target_type = "senate" + elif target and target.title == "Representative": + target_type = "house" + elif target and target.title == "Governor": + target_type = "governor" + if campaign.country_code and campaign.country_code.upper() == "CA" and campaign.campaign_type == "lower": + target_type = "parliament" + return campaign.country_code, target_state, target_type, target.name + + def _get_target_id(self, country, state, target_type, target_name): + target_data = {"country": country, "state": state, "type": target_type} + ak_targets_list = self.ak_client.target.list(**target_data)["objects"] + first_name, last_name = target_name.split(" ", 1) + ak_target = next((target for target in ak_targets_list if target["last"] == last_name and target["first"] == first_name), None) + if not ak_target: + target_data["last"] = last_name + target_data["first"] = first_name + if target_type == "parliament": + target_data["title"] = "MP" + if target_type == "governor": + target_data["title"] = "Governor" + ak_target = self.ak_client.target.create(target_data) + return ak_target["id"] + + def save_action(self, call, crm_campaign_id, crm_user, crm_campaign_key=None): + crm_target_id = self._get_target_id(*self._match_target_data(call)) + call_action = { + "email": crm_user["email"], + "phone": crm_user["phone"], + "page": crm_campaign_id, + "source": "CallPower CRMSync", + "target_checked": crm_target_id, + "action_duration": call.duration, + "action_status": call.status, + "skip_confirmation": 1, + } + result = self.ak_client.action.create(call_action) + return True, result.get("status") + + def save_campaign_meta(self, crm_campaign_id, meta): + response = self.ak_client.get("/rest/v1/page/", params={"name": crm_campaign_id}) + campaign_page = response["objects"][0] + page_custom_fields = {"id": campaign_page["id"]} + for key, value in meta.items(): + page_custom_fields[f"callpower_{key}"] = value + result = self.ak_rpc.Page.set_custom_fields(page_custom_fields) + last_key = f"callpower_{list(meta.keys())[-1]}" if meta else None + return bool(last_key and result.get(last_key) == meta[list(meta.keys())[-1]]) diff --git a/django_app/callpower/crm_sync/integrations/base.py b/django_app/callpower/crm_sync/integrations/base.py new file mode 100644 index 00000000..6f892902 --- /dev/null +++ b/django_app/callpower/crm_sync/integrations/base.py @@ -0,0 +1,39 @@ +from twilio.base.exceptions import TwilioRestException + +from callpower.apps.calls.views import twilio_client + + +class CRMIntegration: + BATCH_ALL_CALLS_IN_SESSION = False + + def __init__(self): + self.twilio_client = twilio_client() + + def get_phone(self, twilio_sid): + twilio_call = self.twilio_client.calls(twilio_sid).fetch() + direction = getattr(twilio_call, "direction", "") or "" + if direction == "inbound": + return twilio_call.from_ + if direction.startswith("outbound"): + return twilio_call.to + return None + + def get_user(self, phone_number): + raise NotImplementedError() + + def save_action(self, call, crm_campaign_id, crm_user, crm_campaign_key=None): + raise NotImplementedError() + + def save_campaign_meta(self, crm_campaign_id, meta): + raise NotImplementedError() + + +class CRMIntegrationError(Exception): + pass + + +def safe_twilio_lookup(integration, twilio_sid): + try: + return integration.get_phone(twilio_sid) + except TwilioRestException as exc: + raise CRMIntegrationError(str(exc)) from exc diff --git a/django_app/callpower/crm_sync/integrations/mobilecommons.py b/django_app/callpower/crm_sync/integrations/mobilecommons.py new file mode 100644 index 00000000..f22ce8c1 --- /dev/null +++ b/django_app/callpower/crm_sync/integrations/mobilecommons.py @@ -0,0 +1,81 @@ +from xml.etree import ElementTree + +import dateutil.parser +from requests.auth import HTTPBasicAuth +from requests_toolbelt import sessions + +from callpower.crm_sync.integrations.base import CRMIntegration + + +class MobileCommonsIntegration(CRMIntegration): + BATCH_ALL_CALLS_IN_SESSION = True + + def __init__(self, username, password, company): + if not username or not password: + raise ValueError("MOBILE_COMMONS_USERNAME and MOBILE_COMMONS_PASSWORD are required") + super().__init__() + self.company = company + self.mc_api = sessions.BaseUrlSession(base_url="https://secure.mcommons.com") + self.mc_api.auth = HTTPBasicAuth(username, password) + + def get_user(self, phone_number): + return {"id": phone_number, "phone": phone_number} + + def ok_to_subscribe_user(self, crm_campaign_id, crm_user): + data = { + "phone_number": crm_user["phone"], + "company": self.company, + } + response = self.mc_api.get("/api/profile", params=data) + try: + results = ElementTree.fromstring(response.content) + except ElementTree.ParseError: + return False, "parse error" + + user_profile = results.find("profile") + if user_profile is None: + return True, None + + profile_subscriptions = user_profile.find("subscriptions") + campaign_subscriptions = [] + for subscription in profile_subscriptions or []: + if subscription.get("campaign_id") == crm_campaign_id: + campaign_subscriptions.append( + { + "created_at": dateutil.parser.isoparse(subscription.get("created_at")), + "status": subscription.get("status"), + } + ) + if not campaign_subscriptions: + return True, None + + campaign_subscriptions.sort(key=lambda item: item["created_at"]) + most_recent = campaign_subscriptions[-1] + if most_recent.get("status") == "Opted-Out": + return False, "opted out" + if most_recent.get("status") == "Active": + return False, "already subscribed" + return True, None + + def save_action(self, call, crm_campaign_id, crm_user, crm_campaign_key=None): + ok, message = self.ok_to_subscribe_user(crm_campaign_id, crm_user) + if not ok: + return False, message + + data = { + "phone_number": crm_user["phone"], + "opt_in_path_id": crm_campaign_key, + "company": self.company, + } + response = self.mc_api.post("/api/profile_update", data) + try: + results = ElementTree.fromstring(response.content) + except ElementTree.ParseError: + return False, "parse error" + + success = results.get("success") == "true" + message = "" if success else (results.find("error").get("message") if results.find("error") is not None else "") + return success, message + + def save_campaign_meta(self, crm_campaign_id, meta): + raise NotImplementedError() diff --git a/django_app/callpower/crm_sync/integrations/noop.py b/django_app/callpower/crm_sync/integrations/noop.py new file mode 100644 index 00000000..ad48c6ea --- /dev/null +++ b/django_app/callpower/crm_sync/integrations/noop.py @@ -0,0 +1,18 @@ +from callpower.crm_sync.integrations.base import CRMIntegration + + +class NoOpIntegration(CRMIntegration): + def __init__(self, default_phone=None): + self.default_phone = default_phone or "+15555550199" + + def get_phone(self, twilio_sid): + return self.default_phone + + def get_user(self, phone_number): + return {"id": phone_number, "phone": phone_number, "email": "noop@example.com"} + + def save_action(self, call, crm_campaign_id, crm_user, crm_campaign_key=None): + return True, f"noop sync for campaign {crm_campaign_id}" + + def save_campaign_meta(self, crm_campaign_id, meta): + return True diff --git a/django_app/callpower/crm_sync/integrations/rogue.py b/django_app/callpower/crm_sync/integrations/rogue.py new file mode 100644 index 00000000..03623dbc --- /dev/null +++ b/django_app/callpower/crm_sync/integrations/rogue.py @@ -0,0 +1,37 @@ +from requests_toolbelt import sessions + +from callpower.crm_sync.integrations.base import CRMIntegration + + +class RogueIntegration(CRMIntegration): + def __init__(self, domain, api_key): + if not domain or not api_key: + raise ValueError("ROGUE_DOMAIN and ROGUE_API_KEY are required") + super().__init__() + self.rogue_session = sessions.BaseUrlSession(base_url=f"https://{domain}") + self.rogue_session.headers = { + "X-DS-Importer-API-Key": api_key, + "Accept": "application/json", + } + + def get_user(self, phone_number): + return {"id": phone_number, "phone": phone_number} + + def save_action(self, call, crm_campaign_id, crm_user, crm_campaign_key=None): + call_action = { + "mobile": crm_user["phone"], + "callpower_campaign_id": call.campaign.id, + "status": call.status, + "call_timestamp": call.timestamp.isoformat() if call.timestamp else "", + "call_duration": call.duration, + "campaign_target_name": call.target.name if call.target else "", + "campaign_target_title": call.target.title if call.target else "", + "campaign_target_district": call.target.district if call.target else "", + "callpower_campaign_name": call.campaign.name if call.campaign else "", + "number_dialed_into": call.session.from_number if call.session else "", + } + response = self.rogue_session.post("/api/v1/callpower/call", json=call_action) + return response.ok, response.text + + def save_campaign_meta(self, crm_campaign_id, meta): + raise NotImplementedError() diff --git a/django_app/callpower/crm_sync/service.py b/django_app/callpower/crm_sync/service.py new file mode 100644 index 00000000..a8642212 --- /dev/null +++ b/django_app/callpower/crm_sync/service.py @@ -0,0 +1,73 @@ +from django.db import transaction +from django.utils import timezone + +from callpower.apps.core.models import Call, SyncCall +from callpower.crm_sync.integrations import get_crm_integration +from callpower.crm_sync.integrations.base import CRMIntegrationError, safe_twilio_lookup + + +@transaction.atomic +def sync_campaign_calls(sync_campaign): + integration = get_crm_integration() + unsynced_calls = ( + Call.objects.filter(campaign=sync_campaign.campaign) + .exclude(sync_records__isnull=False) + .select_related("campaign", "target", "session") + .order_by("timestamp", "id") + ) + + attempted = 0 + saved = 0 + skipped = 0 + + for call in unsynced_calls: + if call.sync_records.exists(): + continue + attempted += 1 + success, sync_call = sync_single_call(sync_campaign, call, integration) + if success: + saved += 1 + if integration.BATCH_ALL_CALLS_IN_SESSION and call.session_id: + sibling_calls = ( + Call.objects.filter(session_id=call.session_id, campaign=sync_campaign.campaign) + .exclude(id=call.id) + .exclude(sync_records__isnull=False) + ) + for sibling in sibling_calls: + SyncCall.objects.create( + call=sibling, + saved=False, + crm_message=f"batched with call {call.id}", + ) + skipped += 1 + + completed_calls = Call.objects.filter(campaign=sync_campaign.campaign, status="completed").count() + try: + integration.save_campaign_meta(sync_campaign.crm_id, {"count": completed_calls}) + except NotImplementedError: + pass + + sync_campaign.last_sync_time = timezone.now() + sync_campaign.save(update_fields=["last_sync_time"]) + return {"attempted": attempted, "saved": saved, "skipped": skipped} + + +def sync_single_call(sync_campaign, call, integration): + if not call.call_id: + return False, None + try: + user_phone = safe_twilio_lookup(integration, call.call_id) + except CRMIntegrationError: + return False, None + if not user_phone: + return False, None + + crm_user = integration.get_user(user_phone) + if not crm_user: + return False, None + + saved, message = integration.save_action(call, sync_campaign.crm_id, crm_user, sync_campaign.crm_key) + if saved: + sync_call = SyncCall.objects.create(call=call, saved=True, crm_message=message or "") + return True, sync_call + return False, None diff --git a/django_app/config/__init__.py b/django_app/config/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/django_app/config/settings.py b/django_app/config/settings.py new file mode 100644 index 00000000..25a1b4c6 --- /dev/null +++ b/django_app/config/settings.py @@ -0,0 +1,163 @@ +import os +from pathlib import Path +import yaml +import dj_database_url + +from dotenv import load_dotenv +load_dotenv() # Explicitly load the .env file + +BASE_DIR = Path(__file__).resolve().parent.parent +REPO_DIR = BASE_DIR.parent + +SECRET_KEY = os.environ.get("DJANGO_SECRET_KEY", "call-power-django-dev-secret") +DEBUG = os.environ.get("DJANGO_DEBUG", "1") == "1" +ALLOWED_HOSTS = [host for host in os.environ.get("DJANGO_ALLOWED_HOSTS", "*").split(",") if host] +CSRF_TRUSTED_ORIGINS = [ + "http://localhost:5173", + "http://127.0.0.1:5173", +] +USE_NGROK = os.environ.get("USE_NGROK", "False") == "True" and os.environ.get("RUN_MAIN", None) != "true" + +INSTALLED_APPS = [ + "django.contrib.admin", + "django.contrib.auth", + "django.contrib.contenttypes", + "django.contrib.sessions", + "django.contrib.messages", + "django.contrib.staticfiles", + "rest_framework", + "callpower.apps.core", + "callpower.apps.api", + "callpower.apps.auth", + "callpower.apps.calls", + "callpower.apps.political_data", + "callpower.apps.public", +] + +MIDDLEWARE = [ + "django.middleware.security.SecurityMiddleware", + "django.contrib.sessions.middleware.SessionMiddleware", + "django.middleware.common.CommonMiddleware", + "django.middleware.csrf.CsrfViewMiddleware", + "django.contrib.auth.middleware.AuthenticationMiddleware", + "django.contrib.messages.middleware.MessageMiddleware", + "django.middleware.clickjacking.XFrameOptionsMiddleware", +] + +ROOT_URLCONF = "config.urls" + +TEMPLATES = [ + { + "BACKEND": "django.template.backends.django.DjangoTemplates", + "DIRS": [BASE_DIR / "templates"], + "APP_DIRS": True, + "OPTIONS": { + "context_processors": [ + "django.template.context_processors.debug", + "django.template.context_processors.request", + "django.contrib.auth.context_processors.auth", + "django.contrib.messages.context_processors.messages", + ], + }, + } +] + +WSGI_APPLICATION = "config.wsgi.application" + +default_db = os.environ.get("DATABASE_URI") or os.environ.get("DATABASE_URL") +if default_db: + DATABASES = { + "default": dj_database_url.parse(default_db, conn_max_age=600), + } +else: + DATABASES = { + "default": { + "ENGINE": "django.db.backends.sqlite3", + "NAME": REPO_DIR / "dev.db", + } + } + +LANGUAGE_CODE = "en-us" +TIME_ZONE = "UTC" +USE_I18N = True +USE_TZ = True +LOGIN_URL = "/user/login/" + +STATIC_URL = "/static/" +STATICFILES_DIRS = [BASE_DIR / "static", REPO_DIR / "call_server" / "static"] +STATIC_ROOT = REPO_DIR / "staticfiles" +MEDIA_URL = "/media/" +MEDIA_ROOT = REPO_DIR / "instance" / "uploads" + +DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField" + +REST_FRAMEWORK = { + "DEFAULT_RENDERER_CLASSES": [ + "rest_framework.renderers.JSONRenderer", + ], +} + +AUTHENTICATION_BACKENDS = [ + "callpower.auth_backends.LegacyUserBackend", +] + +REACT_DEV_SERVER_URL = os.environ.get("REACT_DEV_SERVER_URL", "http://localhost:5173") +INSTALLED_ORG = os.environ.get("INSTALLED_ORG", "OpenSourceActivism.tech") +SITENAME = os.environ.get("SITENAME", "Call Power") +SENTRY_DSN_PUBLIC_KEY = os.environ.get("SENTRY_DSN_PUBLIC_KEY", "") + +TWILIO_ACCOUNT_SID = os.environ.get("TWILIO_ACCOUNT_SID") +if not TWILIO_ACCOUNT_SID: + print("Warning: TWILIO_ACCOUNT_SID not set, Twilio integration will not work") +TWILIO_AUTH_TOKEN = os.environ.get("TWILIO_AUTH_TOKEN") +TWILIO_TIME_LIMIT = int(os.environ.get("TWILIO_TIME_LIMIT", 60 * 60)) +TWILIO_TIMEOUT = int(os.environ.get("TWILIO_TIMEOUT", 60)) +LOG_PHONE_NUMBERS = os.environ.get("LOG_PHONE_NUMBERS", "true").lower() in {"1", "true", "yes", "on"} + +CRM_INTEGRATION = os.environ.get("CRM_INTEGRATION", "") +CRM_DEBUG_PHONE = os.environ.get("CRM_DEBUG_PHONE", "+15555550199") +ACTIONKIT_DOMAIN = os.environ.get("ACTIONKIT_DOMAIN") +ACTIONKIT_USER = os.environ.get("ACTIONKIT_USER") +ACTIONKIT_PASSWORD = os.environ.get("ACTIONKIT_PASSWORD") +ACTIONKIT_API_KEY = os.environ.get("ACTIONKIT_API_KEY") +ROGUE_DOMAIN = os.environ.get("ROGUE_DOMAIN") +ROGUE_API_KEY = os.environ.get("ROGUE_API_KEY") +MOBILE_COMMONS_USERNAME = os.environ.get("MOBILE_COMMONS_USERNAME") +MOBILE_COMMONS_PASSWORD = os.environ.get("MOBILE_COMMONS_PASSWORD") +MOBILE_COMMONS_COMPANY = os.environ.get("MOBILE_COMMONS_COMPANY") +EMAIL_BACKEND = os.environ.get( + "EMAIL_BACKEND", + "django.core.mail.backends.console.EmailBackend" if DEBUG else "django.core.mail.backends.smtp.EmailBackend", +) +EMAIL_HOST = os.environ.get("EMAIL_HOST", "localhost") +EMAIL_PORT = int(os.environ.get("EMAIL_PORT", 25)) +EMAIL_HOST_USER = os.environ.get("EMAIL_HOST_USER", "") +EMAIL_HOST_PASSWORD = os.environ.get("EMAIL_HOST_PASSWORD", "") +EMAIL_USE_TLS = os.environ.get("EMAIL_USE_TLS", "0") == "1" +DEFAULT_FROM_EMAIL = os.environ.get("DEFAULT_FROM_EMAIL", f"no-reply@{INSTALLED_ORG.lower()}") +ADMIN_EMAIL = os.environ.get("ADMIN_EMAIL", DEFAULT_FROM_EMAIL) + +CAMPAIGN_MESSAGE_DEFAULTS = yaml.safe_load((REPO_DIR / "instance" / "campaign_msg_defaults.yaml").read_text()) + +STORAGES = { + "default": { + "BACKEND": "django.core.files.storage.FileSystemStorage", + "OPTIONS": { + "location": MEDIA_ROOT, + "base_url": MEDIA_URL, + }, + }, + "staticfiles": { + "BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage", + }, +} + +CACHES = { + "default": { + "BACKEND": "django.core.cache.backends.locmem.LocMemCache", + "LOCATION": "call-power-django", + "OPTIONS": { + "MAX_ENTRIES": 100000, + }, + } +} diff --git a/django_app/config/urls.py b/django_app/config/urls.py new file mode 100644 index 00000000..69732aa7 --- /dev/null +++ b/django_app/config/urls.py @@ -0,0 +1,20 @@ +from django.contrib import admin +from django.urls import include, path +from django.conf import settings +from django.conf.urls.static import static + +from callpower.apps.api.views import AdminAppView + + +urlpatterns = [ + path("django-admin/", admin.site.urls), + path("", include("callpower.apps.auth.urls")), + path("api/", include("callpower.apps.api.urls")), + path("call/", include("callpower.apps.calls.urls")), + path("political_data/", include("callpower.apps.political_data.urls")), + path("admin/", AdminAppView.as_view(), name="admin-app"), + path("", include("callpower.apps.public.urls")), +] + +if settings.DEBUG: + urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) diff --git a/django_app/config/wsgi.py b/django_app/config/wsgi.py new file mode 100644 index 00000000..676eb2e4 --- /dev/null +++ b/django_app/config/wsgi.py @@ -0,0 +1,10 @@ +import os +import sys + +from django.core.wsgi import get_wsgi_application + + +sys.path.insert(0, os.path.dirname(os.path.dirname(__file__))) +os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings") + +application = get_wsgi_application() diff --git a/django_app/static/admin/assets/index.css b/django_app/static/admin/assets/index.css new file mode 100644 index 00000000..a6303ff1 --- /dev/null +++ b/django_app/static/admin/assets/index.css @@ -0,0 +1 @@ +:root{color:#172033;background:radial-gradient(circle at top left,rgba(245,179,66,.24),transparent 26%),linear-gradient(135deg,#f4efe4,#dbe7f2);font-family:Avenir Next,Segoe UI,sans-serif}*{box-sizing:border-box}body{margin:0;min-height:100vh}.login-page{min-height:100vh;display:grid;place-items:center;padding:24px}.login-panel{width:min(100%,460px)}.page{max-width:1100px;margin:0 auto;padding:48px 20px 72px}.hero{display:grid;gap:24px;align-items:end;grid-template-columns:minmax(0,1fr) 280px;margin-bottom:28px}.hero-actions{display:grid;gap:12px}.account-links{display:flex;gap:12px;flex-wrap:wrap}.session-label{margin:0;font-size:.92rem;font-weight:600;color:#24324b}.hero h1,.panel h2{font-family:Georgia,Times New Roman,serif;letter-spacing:-.03em;margin:8px 0}.hero p,.panel p,th,td,.stat-card p{color:#40506b}.eyebrow{color:#8a4b08;font-size:.78rem;font-weight:700;letter-spacing:.12em;text-transform:uppercase}.search,.panel,.stat-card,.button,.field input,.field select,.field textarea{border:1px solid rgba(23,32,51,.08);box-shadow:0 16px 40px #17203314}.search{width:100%;border-radius:999px;padding:15px 18px;background:#ffffffe6}.stats-grid{display:grid;gap:16px;grid-template-columns:repeat(4,minmax(0,1fr));margin-bottom:24px}.stat-card,.panel{border-radius:24px;background:#ffffffdb;-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px)}.stat-card{padding:20px}.stat-card strong{font-size:2rem}.panel{padding:24px}.workspace{display:grid;grid-template-columns:1.1fr .9fr;gap:20px;margin-bottom:20px}.panel-header{display:flex;justify-content:space-between;gap:16px;align-items:end;margin-bottom:16px}table{width:100%;border-collapse:collapse}th,td{text-align:left;padding:14px 10px;border-top:1px solid rgba(23,32,51,.08)}tbody tr{cursor:pointer}.active-row{background:#f5b3422e}.editor-form,.field-grid,.toggle-grid{display:grid;gap:14px}.field-grid{grid-template-columns:repeat(2,minmax(0,1fr))}.field{display:grid;gap:6px;font-size:.92rem}.field span,.toggle span{font-weight:600;color:#24324b}.field input,.field select,.field textarea{width:100%;padding:12px 14px;border-radius:16px;background:#ffffffeb;resize:vertical}.multi-select{min-height:132px}.toggle-grid{grid-template-columns:repeat(2,minmax(0,1fr))}.toggle{display:flex;gap:10px;align-items:center;padding:12px 14px;border-radius:16px;background:#ffffffb8}.button{display:inline-flex;align-items:center;justify-content:center;border-radius:999px;padding:12px 18px;background:#ffffffeb;cursor:pointer;color:inherit;text-decoration:none}.button-accent{background:#172033;color:#fffaf0}.editor-actions,.form-actions{display:flex;gap:12px;align-items:center;justify-content:flex-end}.status-message{margin:0;font-size:.9rem}.status-success{color:#10613f}.status-error{color:#a62f26}.status-saving{color:#8a4b08}.section-divider h3{margin:4px 0 0;font-family:Georgia,Times New Roman,serif}.audio-panel{margin-top:0}.audio-list{display:grid;gap:14px;margin-top:18px}.audio-card{border:1px solid rgba(23,32,51,.08);border-radius:20px;padding:16px;background:#ffffffc2}.audio-card-selected{border-color:#8a4b0859;background:#f5b3421f}.audio-card-header,.audio-actions,.audio-badges{display:flex;gap:10px;align-items:center;justify-content:space-between}.audio-badges{justify-content:flex-end}.badge{display:inline-flex;align-items:center;border-radius:999px;padding:4px 10px;background:#17203314;font-size:.8rem}.badge-active{background:#10613f24;color:#10613f}.audio-copy{margin:10px 0;padding:12px;border-radius:14px;background:#1720330d;white-space:pre-wrap;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:.86rem}.empty-state{padding:18px;border-radius:16px;background:#ffffffb3}audio{width:100%;margin:8px 0 12px}@media(max-width:800px){.hero,.stats-grid,.panel-header,.workspace,.field-grid,.toggle-grid{grid-template-columns:1fr;display:grid}table{display:block;overflow-x:auto}} diff --git a/django_app/static/admin/index.html b/django_app/static/admin/index.html new file mode 100644 index 00000000..72b1e4da --- /dev/null +++ b/django_app/static/admin/index.html @@ -0,0 +1,13 @@ + + + + + + Call Power Admin + + + + +
+ + diff --git a/django_app/static/admin/index.js b/django_app/static/admin/index.js new file mode 100644 index 00000000..bdaa6037 --- /dev/null +++ b/django_app/static/admin/index.js @@ -0,0 +1,40 @@ +(function(){const R=document.createElement("link").relList;if(R&&R.supports&&R.supports("modulepreload"))return;for(const A of document.querySelectorAll('link[rel="modulepreload"]'))W(A);new MutationObserver(A=>{for(const F of A)if(F.type==="childList")for(const T of F.addedNodes)T.tagName==="LINK"&&T.rel==="modulepreload"&&W(T)}).observe(document,{childList:!0,subtree:!0});function g(A){const F={};return A.integrity&&(F.integrity=A.integrity),A.referrerPolicy&&(F.referrerPolicy=A.referrerPolicy),A.crossOrigin==="use-credentials"?F.credentials="include":A.crossOrigin==="anonymous"?F.credentials="omit":F.credentials="same-origin",F}function W(A){if(A.ep)return;A.ep=!0;const F=g(A);fetch(A.href,F)}})();function Aa(x){return x&&x.__esModule&&Object.prototype.hasOwnProperty.call(x,"default")?x.default:x}var Di={exports:{}},Tr={},Mi={exports:{}},Q={};/** + * @license React + * react.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var Ta;function Ff(){if(Ta)return Q;Ta=1;var x=Symbol.for("react.element"),R=Symbol.for("react.portal"),g=Symbol.for("react.fragment"),W=Symbol.for("react.strict_mode"),A=Symbol.for("react.profiler"),F=Symbol.for("react.provider"),T=Symbol.for("react.context"),b=Symbol.for("react.forward_ref"),ee=Symbol.for("react.suspense"),_e=Symbol.for("react.memo"),Te=Symbol.for("react.lazy"),le=Symbol.iterator;function ie(d){return d===null||typeof d!="object"?null:(d=le&&d[le]||d["@@iterator"],typeof d=="function"?d:null)}var Ie={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},Fe=Object.assign,oe={};function J(d,v,V){this.props=d,this.context=v,this.refs=oe,this.updater=V||Ie}J.prototype.isReactComponent={},J.prototype.setState=function(d,v){if(typeof d!="object"&&typeof d!="function"&&d!=null)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,d,v,"setState")},J.prototype.forceUpdate=function(d){this.updater.enqueueForceUpdate(this,d,"forceUpdate")};function mt(){}mt.prototype=J.prototype;function Y(d,v,V){this.props=d,this.context=v,this.refs=oe,this.updater=V||Ie}var ke=Y.prototype=new mt;ke.constructor=Y,Fe(ke,J.prototype),ke.isPureReactComponent=!0;var O=Array.isArray,Le=Object.prototype.hasOwnProperty,ne={current:null},je={key:!0,ref:!0,__self:!0,__source:!0};function Ve(d,v,V){var B,K={},X=null,re=null;if(v!=null)for(B in v.ref!==void 0&&(re=v.ref),v.key!==void 0&&(X=""+v.key),v)Le.call(v,B)&&!je.hasOwnProperty(B)&&(K[B]=v[B]);var q=arguments.length-2;if(q===1)K.children=V;else if(1>>1,v=C[d];if(0>>1;dA(K,k))XA(re,K)?(C[d]=re,C[X]=k,d=X):(C[d]=K,C[B]=k,d=B);else if(XA(re,k))C[d]=re,C[X]=k,d=X;else break e}}return z}function A(C,z){var k=C.sortIndex-z.sortIndex;return k!==0?k:C.id-z.id}if(typeof performance=="object"&&typeof performance.now=="function"){var F=performance;x.unstable_now=function(){return F.now()}}else{var T=Date,b=T.now();x.unstable_now=function(){return T.now()-b}}var ee=[],_e=[],Te=1,le=null,ie=3,Ie=!1,Fe=!1,oe=!1,J=typeof setTimeout=="function"?setTimeout:null,mt=typeof clearTimeout=="function"?clearTimeout:null,Y=typeof setImmediate<"u"?setImmediate:null;typeof navigator<"u"&&navigator.scheduling!==void 0&&navigator.scheduling.isInputPending!==void 0&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function ke(C){for(var z=g(_e);z!==null;){if(z.callback===null)W(_e);else if(z.startTime<=C)W(_e),z.sortIndex=z.expirationTime,R(ee,z);else break;z=g(_e)}}function O(C){if(oe=!1,ke(C),!Fe)if(g(ee)!==null)Fe=!0,we(Le);else{var z=g(_e);z!==null&&ae(O,z.startTime-C)}}function Le(C,z){Fe=!1,oe&&(oe=!1,mt(Ve),Ve=-1),Ie=!0;var k=ie;try{for(ke(z),le=g(ee);le!==null&&(!(le.expirationTime>z)||C&&!ot());){var d=le.callback;if(typeof d=="function"){le.callback=null,ie=le.priorityLevel;var v=d(le.expirationTime<=z);z=x.unstable_now(),typeof v=="function"?le.callback=v:le===g(ee)&&W(ee),ke(z)}else W(ee);le=g(ee)}if(le!==null)var V=!0;else{var B=g(_e);B!==null&&ae(O,B.startTime-z),V=!1}return V}finally{le=null,ie=k,Ie=!1}}var ne=!1,je=null,Ve=-1,ge=5,ht=-1;function ot(){return!(x.unstable_now()-htC||125d?(C.sortIndex=k,R(_e,C),g(ee)===null&&C===g(_e)&&(oe?(mt(Ve),Ve=-1):oe=!0,ae(O,k-d))):(C.sortIndex=v,R(ee,C),Fe||Ie||(Fe=!0,we(Le))),C},x.unstable_shouldYield=ot,x.unstable_wrapCallback=function(C){var z=ie;return function(){var k=ie;ie=z;try{return C.apply(this,arguments)}finally{ie=k}}}})(Ui)),Ui}var Da;function Hf(){return Da||(Da=1,Fi.exports=Bf()),Fi.exports}/** + * @license React + * react-dom.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var Ma;function $f(){if(Ma)return tt;Ma=1;var x=Ai(),R=Hf();function g(e){for(var t="https://reactjs.org/docs/error-decoder.html?invariant="+e,n=1;n"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),ee=Object.prototype.hasOwnProperty,_e=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,Te={},le={};function ie(e){return ee.call(le,e)?!0:ee.call(Te,e)?!1:_e.test(e)?le[e]=!0:(Te[e]=!0,!1)}function Ie(e,t,n,r){if(n!==null&&n.type===0)return!1;switch(typeof t){case"function":case"symbol":return!0;case"boolean":return r?!1:n!==null?!n.acceptsBooleans:(e=e.toLowerCase().slice(0,5),e!=="data-"&&e!=="aria-");default:return!1}}function Fe(e,t,n,r){if(t===null||typeof t>"u"||Ie(e,t,n,r))return!0;if(r)return!1;if(n!==null)switch(n.type){case 3:return!t;case 4:return t===!1;case 5:return isNaN(t);case 6:return isNaN(t)||1>t}return!1}function oe(e,t,n,r,l,u,i){this.acceptsBooleans=t===2||t===3||t===4,this.attributeName=r,this.attributeNamespace=l,this.mustUseProperty=n,this.propertyName=e,this.type=t,this.sanitizeURL=u,this.removeEmptyString=i}var J={};"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(e){J[e]=new oe(e,0,!1,e,null,!1,!1)}),[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(e){var t=e[0];J[t]=new oe(t,1,!1,e[1],null,!1,!1)}),["contentEditable","draggable","spellCheck","value"].forEach(function(e){J[e]=new oe(e,2,!1,e.toLowerCase(),null,!1,!1)}),["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(e){J[e]=new oe(e,2,!1,e,null,!1,!1)}),"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(e){J[e]=new oe(e,3,!1,e.toLowerCase(),null,!1,!1)}),["checked","multiple","muted","selected"].forEach(function(e){J[e]=new oe(e,3,!0,e,null,!1,!1)}),["capture","download"].forEach(function(e){J[e]=new oe(e,4,!1,e,null,!1,!1)}),["cols","rows","size","span"].forEach(function(e){J[e]=new oe(e,6,!1,e,null,!1,!1)}),["rowSpan","start"].forEach(function(e){J[e]=new oe(e,5,!1,e.toLowerCase(),null,!1,!1)});var mt=/[\-:]([a-z])/g;function Y(e){return e[1].toUpperCase()}"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(e){var t=e.replace(mt,Y);J[t]=new oe(t,1,!1,e,null,!1,!1)}),"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(e){var t=e.replace(mt,Y);J[t]=new oe(t,1,!1,e,"http://www.w3.org/1999/xlink",!1,!1)}),["xml:base","xml:lang","xml:space"].forEach(function(e){var t=e.replace(mt,Y);J[t]=new oe(t,1,!1,e,"http://www.w3.org/XML/1998/namespace",!1,!1)}),["tabIndex","crossOrigin"].forEach(function(e){J[e]=new oe(e,1,!1,e.toLowerCase(),null,!1,!1)}),J.xlinkHref=new oe("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1),["src","href","action","formAction"].forEach(function(e){J[e]=new oe(e,1,!1,e.toLowerCase(),null,!0,!0)});function ke(e,t,n,r){var l=J.hasOwnProperty(t)?J[t]:null;(l!==null?l.type!==0:r||!(2o||l[i]!==u[o]){var a=` +`+l[i].replace(" at new "," at ");return e.displayName&&a.includes("")&&(a=a.replace("",e.displayName)),a}while(1<=i&&0<=o);break}}}finally{V=!1,Error.prepareStackTrace=n}return(e=e?e.displayName||e.name:"")?v(e):""}function K(e){switch(e.tag){case 5:return v(e.type);case 16:return v("Lazy");case 13:return v("Suspense");case 19:return v("SuspenseList");case 0:case 2:case 15:return e=B(e.type,!1),e;case 11:return e=B(e.type.render,!1),e;case 1:return e=B(e.type,!0),e;default:return""}}function X(e){if(e==null)return null;if(typeof e=="function")return e.displayName||e.name||null;if(typeof e=="string")return e;switch(e){case je:return"Fragment";case ne:return"Portal";case ge:return"Profiler";case Ve:return"StrictMode";case Be:return"Suspense";case nt:return"SuspenseList"}if(typeof e=="object")switch(e.$$typeof){case ot:return(e.displayName||"Context")+".Consumer";case ht:return(e._context.displayName||"Context")+".Provider";case ze:var t=e.render;return e=e.displayName,e||(e=t.displayName||t.name||"",e=e!==""?"ForwardRef("+e+")":"ForwardRef"),e;case Ce:return t=e.displayName||null,t!==null?t:X(e.type)||"Memo";case we:t=e._payload,e=e._init;try{return X(e(t))}catch{}}return null}function re(e){var t=e.type;switch(e.tag){case 24:return"Cache";case 9:return(t.displayName||"Context")+".Consumer";case 10:return(t._context.displayName||"Context")+".Provider";case 18:return"DehydratedFragment";case 11:return e=t.render,e=e.displayName||e.name||"",t.displayName||(e!==""?"ForwardRef("+e+")":"ForwardRef");case 7:return"Fragment";case 5:return t;case 4:return"Portal";case 3:return"Root";case 6:return"Text";case 16:return X(t);case 8:return t===Ve?"StrictMode":"Mode";case 22:return"Offscreen";case 12:return"Profiler";case 21:return"Scope";case 13:return"Suspense";case 19:return"SuspenseList";case 25:return"TracingMarker";case 1:case 0:case 17:case 2:case 14:case 15:if(typeof t=="function")return t.displayName||t.name||null;if(typeof t=="string")return t}return null}function q(e){switch(typeof e){case"boolean":case"number":case"string":case"undefined":return e;case"object":return e;default:return""}}function ue(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()==="input"&&(t==="checkbox"||t==="radio")}function Ke(e){var t=ue(e)?"checked":"value",n=Object.getOwnPropertyDescriptor(e.constructor.prototype,t),r=""+e[t];if(!e.hasOwnProperty(t)&&typeof n<"u"&&typeof n.get=="function"&&typeof n.set=="function"){var l=n.get,u=n.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return l.call(this)},set:function(i){r=""+i,u.call(this,i)}}),Object.defineProperty(e,t,{enumerable:n.enumerable}),{getValue:function(){return r},setValue:function(i){r=""+i},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function hn(e){e._valueTracker||(e._valueTracker=Ke(e))}function Lr(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var n=t.getValue(),r="";return e&&(r=ue(e)?e.checked?"true":"false":e.value),e=r,e!==n?(t.setValue(e),!0):!1}function vn(e){if(e=e||(typeof document<"u"?document:void 0),typeof e>"u")return null;try{return e.activeElement||e.body}catch{return e.body}}function Hn(e,t){var n=t.checked;return k({},t,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:n??e._wrapperState.initialChecked})}function zr(e,t){var n=t.defaultValue==null?"":t.defaultValue,r=t.checked!=null?t.checked:t.defaultChecked;n=q(t.value!=null?t.value:n),e._wrapperState={initialChecked:r,initialValue:n,controlled:t.type==="checkbox"||t.type==="radio"?t.checked!=null:t.value!=null}}function $n(e,t){t=t.checked,t!=null&&ke(e,"checked",t,!1)}function gn(e,t){$n(e,t);var n=q(t.value),r=t.type;if(n!=null)r==="number"?(n===0&&e.value===""||e.value!=n)&&(e.value=""+n):e.value!==""+n&&(e.value=""+n);else if(r==="submit"||r==="reset"){e.removeAttribute("value");return}t.hasOwnProperty("value")?I(e,t.type,n):t.hasOwnProperty("defaultValue")&&I(e,t.type,q(t.defaultValue)),t.checked==null&&t.defaultChecked!=null&&(e.defaultChecked=!!t.defaultChecked)}function f(e,t,n){if(t.hasOwnProperty("value")||t.hasOwnProperty("defaultValue")){var r=t.type;if(!(r!=="submit"&&r!=="reset"||t.value!==void 0&&t.value!==null))return;t=""+e._wrapperState.initialValue,n||t===e.value||(e.value=t),e.defaultValue=t}n=e.name,n!==""&&(e.name=""),e.defaultChecked=!!e._wrapperState.initialChecked,n!==""&&(e.name=n)}function I(e,t,n){(t!=="number"||vn(e.ownerDocument)!==e)&&(n==null?e.defaultValue=""+e._wrapperState.initialValue:e.defaultValue!==""+n&&(e.defaultValue=""+n))}var $=Array.isArray;function me(e,t,n,r){if(e=e.options,t){t={};for(var l=0;l"+t.valueOf().toString()+"",t=Or.firstChild;e.firstChild;)e.removeChild(e.firstChild);for(;t.firstChild;)e.appendChild(t.firstChild)}});function Wn(e,t){if(t){var n=e.firstChild;if(n&&n===e.lastChild&&n.nodeType===3){n.nodeValue=t;return}}e.textContent=t}var Kn={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},Va=["Webkit","ms","Moz","O"];Object.keys(Kn).forEach(function(e){Va.forEach(function(t){t=t+e.charAt(0).toUpperCase()+e.substring(1),Kn[t]=Kn[e]})});function $i(e,t,n){return t==null||typeof t=="boolean"||t===""?"":n||typeof t!="number"||t===0||Kn.hasOwnProperty(e)&&Kn[e]?(""+t).trim():t+"px"}function Qi(e,t){e=e.style;for(var n in t)if(t.hasOwnProperty(n)){var r=n.indexOf("--")===0,l=$i(n,t[n],r);n==="float"&&(n="cssFloat"),r?e.setProperty(n,l):e[n]=l}}var Ba=k({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});function Kl(e,t){if(t){if(Ba[e]&&(t.children!=null||t.dangerouslySetInnerHTML!=null))throw Error(g(137,e));if(t.dangerouslySetInnerHTML!=null){if(t.children!=null)throw Error(g(60));if(typeof t.dangerouslySetInnerHTML!="object"||!("__html"in t.dangerouslySetInnerHTML))throw Error(g(61))}if(t.style!=null&&typeof t.style!="object")throw Error(g(62))}}function Yl(e,t){if(e.indexOf("-")===-1)return typeof t.is=="string";switch(e){case"annotation-xml":case"color-profile":case"font-face":case"font-face-src":case"font-face-uri":case"font-face-format":case"font-face-name":case"missing-glyph":return!1;default:return!0}}var Xl=null;function Gl(e){return e=e.target||e.srcElement||window,e.correspondingUseElement&&(e=e.correspondingUseElement),e.nodeType===3?e.parentNode:e}var Jl=null,yn=null,wn=null;function Wi(e){if(e=mr(e)){if(typeof Jl!="function")throw Error(g(280));var t=e.stateNode;t&&(t=nl(t),Jl(e.stateNode,e.type,t))}}function Ki(e){yn?wn?wn.push(e):wn=[e]:yn=e}function Yi(){if(yn){var e=yn,t=wn;if(wn=yn=null,Wi(e),t)for(e=0;e>>=0,e===0?32:31-(qa(e)/ba|0)|0}var Ur=64,Ar=4194304;function Jn(e){switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return e&4194240;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return e&130023424;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;default:return e}}function Vr(e,t){var n=e.pendingLanes;if(n===0)return 0;var r=0,l=e.suspendedLanes,u=e.pingedLanes,i=n&268435455;if(i!==0){var o=i&~l;o!==0?r=Jn(o):(u&=i,u!==0&&(r=Jn(u)))}else i=n&~l,i!==0?r=Jn(i):u!==0&&(r=Jn(u));if(r===0)return 0;if(t!==0&&t!==r&&(t&l)===0&&(l=r&-r,u=t&-t,l>=u||l===16&&(u&4194240)!==0))return t;if((r&4)!==0&&(r|=n&16),t=e.entangledLanes,t!==0)for(e=e.entanglements,t&=r;0n;n++)t.push(e);return t}function Zn(e,t,n){e.pendingLanes|=t,t!==536870912&&(e.suspendedLanes=0,e.pingedLanes=0),e=e.eventTimes,t=31-vt(t),e[t]=n}function rc(e,t){var n=e.pendingLanes&~t;e.pendingLanes=t,e.suspendedLanes=0,e.pingedLanes=0,e.expiredLanes&=t,e.mutableReadLanes&=t,e.entangledLanes&=t,t=e.entanglements;var r=e.eventTimes;for(e=e.expirationTimes;0=ur),_o=" ",ko=!1;function Co(e,t){switch(e){case"keyup":return zc.indexOf(t.keyCode)!==-1;case"keydown":return t.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function Eo(e){return e=e.detail,typeof e=="object"&&"data"in e?e.data:null}var _n=!1;function Oc(e,t){switch(e){case"compositionend":return Eo(t);case"keypress":return t.which!==32?null:(ko=!0,_o);case"textInput":return e=t.data,e===_o&&ko?null:e;default:return null}}function Dc(e,t){if(_n)return e==="compositionend"||!mu&&Co(e,t)?(e=vo(),Wr=su=Vt=null,_n=!1,e):null;switch(e){case"paste":return null;case"keypress":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1=t)return{node:n,offset:t-e};e=r}e:{for(;n;){if(n.nextSibling){n=n.nextSibling;break e}n=n.parentNode}n=void 0}n=Ro(n)}}function Do(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?Do(e,t.parentNode):"contains"in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function Mo(){for(var e=window,t=vn();t instanceof e.HTMLIFrameElement;){try{var n=typeof t.contentWindow.location.href=="string"}catch{n=!1}if(n)e=t.contentWindow;else break;t=vn(e.document)}return t}function gu(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t==="input"&&(e.type==="text"||e.type==="search"||e.type==="tel"||e.type==="url"||e.type==="password")||t==="textarea"||e.contentEditable==="true")}function $c(e){var t=Mo(),n=e.focusedElem,r=e.selectionRange;if(t!==n&&n&&n.ownerDocument&&Do(n.ownerDocument.documentElement,n)){if(r!==null&&gu(n)){if(t=r.start,e=r.end,e===void 0&&(e=t),"selectionStart"in n)n.selectionStart=t,n.selectionEnd=Math.min(e,n.value.length);else if(e=(t=n.ownerDocument||document)&&t.defaultView||window,e.getSelection){e=e.getSelection();var l=n.textContent.length,u=Math.min(r.start,l);r=r.end===void 0?u:Math.min(r.end,l),!e.extend&&u>r&&(l=r,r=u,u=l),l=Oo(n,u);var i=Oo(n,r);l&&i&&(e.rangeCount!==1||e.anchorNode!==l.node||e.anchorOffset!==l.offset||e.focusNode!==i.node||e.focusOffset!==i.offset)&&(t=t.createRange(),t.setStart(l.node,l.offset),e.removeAllRanges(),u>r?(e.addRange(t),e.extend(i.node,i.offset)):(t.setEnd(i.node,i.offset),e.addRange(t)))}}for(t=[],e=n;e=e.parentNode;)e.nodeType===1&&t.push({element:e,left:e.scrollLeft,top:e.scrollTop});for(typeof n.focus=="function"&&n.focus(),n=0;n=document.documentMode,kn=null,yu=null,ar=null,wu=!1;function Io(e,t,n){var r=n.window===n?n.document:n.nodeType===9?n:n.ownerDocument;wu||kn==null||kn!==vn(r)||(r=kn,"selectionStart"in r&&gu(r)?r={start:r.selectionStart,end:r.selectionEnd}:(r=(r.ownerDocument&&r.ownerDocument.defaultView||window).getSelection(),r={anchorNode:r.anchorNode,anchorOffset:r.anchorOffset,focusNode:r.focusNode,focusOffset:r.focusOffset}),ar&&sr(ar,r)||(ar=r,r=br(yu,"onSelect"),0Pn||(e.current=zu[Pn],zu[Pn]=null,Pn--)}function se(e,t){Pn++,zu[Pn]=e.current,e.current=t}var Qt={},He=$t(Qt),Je=$t(!1),rn=Qt;function Tn(e,t){var n=e.type.contextTypes;if(!n)return Qt;var r=e.stateNode;if(r&&r.__reactInternalMemoizedUnmaskedChildContext===t)return r.__reactInternalMemoizedMaskedChildContext;var l={},u;for(u in n)l[u]=t[u];return r&&(e=e.stateNode,e.__reactInternalMemoizedUnmaskedChildContext=t,e.__reactInternalMemoizedMaskedChildContext=l),l}function Ze(e){return e=e.childContextTypes,e!=null}function rl(){fe(Je),fe(He)}function Zo(e,t,n){if(He.current!==Qt)throw Error(g(168));se(He,t),se(Je,n)}function qo(e,t,n){var r=e.stateNode;if(t=t.childContextTypes,typeof r.getChildContext!="function")return n;r=r.getChildContext();for(var l in r)if(!(l in t))throw Error(g(108,re(e)||"Unknown",l));return k({},n,r)}function ll(e){return e=(e=e.stateNode)&&e.__reactInternalMemoizedMergedChildContext||Qt,rn=He.current,se(He,e),se(Je,Je.current),!0}function bo(e,t,n){var r=e.stateNode;if(!r)throw Error(g(169));n?(e=qo(e,t,rn),r.__reactInternalMemoizedMergedChildContext=e,fe(Je),fe(He),se(He,e)):fe(Je),se(Je,n)}var Tt=null,ul=!1,Ru=!1;function es(e){Tt===null?Tt=[e]:Tt.push(e)}function tf(e){ul=!0,es(e)}function Wt(){if(!Ru&&Tt!==null){Ru=!0;var e=0,t=te;try{var n=Tt;for(te=1;e>=i,l-=i,Lt=1<<32-vt(t)+l|n<U?(De=M,M=null):De=M.sibling;var Z=y(p,M,m[U],_);if(Z===null){M===null&&(M=De);break}e&&M&&Z.alternate===null&&t(p,M),c=u(Z,c,U),D===null?L=Z:D.sibling=Z,D=Z,M=De}if(U===m.length)return n(p,M),pe&&un(p,U),L;if(M===null){for(;UU?(De=M,M=null):De=M.sibling;var en=y(p,M,Z.value,_);if(en===null){M===null&&(M=De);break}e&&M&&en.alternate===null&&t(p,M),c=u(en,c,U),D===null?L=en:D.sibling=en,D=en,M=De}if(Z.done)return n(p,M),pe&&un(p,U),L;if(M===null){for(;!Z.done;U++,Z=m.next())Z=S(p,Z.value,_),Z!==null&&(c=u(Z,c,U),D===null?L=Z:D.sibling=Z,D=Z);return pe&&un(p,U),L}for(M=r(p,M);!Z.done;U++,Z=m.next())Z=E(M,p,U,Z.value,_),Z!==null&&(e&&Z.alternate!==null&&M.delete(Z.key===null?U:Z.key),c=u(Z,c,U),D===null?L=Z:D.sibling=Z,D=Z);return e&&M.forEach(function(If){return t(p,If)}),pe&&un(p,U),L}function Se(p,c,m,_){if(typeof m=="object"&&m!==null&&m.type===je&&m.key===null&&(m=m.props.children),typeof m=="object"&&m!==null){switch(m.$$typeof){case Le:e:{for(var L=m.key,D=c;D!==null;){if(D.key===L){if(L=m.type,L===je){if(D.tag===7){n(p,D.sibling),c=l(D,m.props.children),c.return=p,p=c;break e}}else if(D.elementType===L||typeof L=="object"&&L!==null&&L.$$typeof===we&&is(L)===D.type){n(p,D.sibling),c=l(D,m.props),c.ref=hr(p,D,m),c.return=p,p=c;break e}n(p,D);break}else t(p,D);D=D.sibling}m.type===je?(c=mn(m.props.children,p.mode,_,m.key),c.return=p,p=c):(_=Ol(m.type,m.key,m.props,null,p.mode,_),_.ref=hr(p,c,m),_.return=p,p=_)}return i(p);case ne:e:{for(D=m.key;c!==null;){if(c.key===D)if(c.tag===4&&c.stateNode.containerInfo===m.containerInfo&&c.stateNode.implementation===m.implementation){n(p,c.sibling),c=l(c,m.children||[]),c.return=p,p=c;break e}else{n(p,c);break}else t(p,c);c=c.sibling}c=Ti(m,p.mode,_),c.return=p,p=c}return i(p);case we:return D=m._init,Se(p,c,D(m._payload),_)}if($(m))return N(p,c,m,_);if(z(m))return P(p,c,m,_);al(p,m)}return typeof m=="string"&&m!==""||typeof m=="number"?(m=""+m,c!==null&&c.tag===6?(n(p,c.sibling),c=l(c,m),c.return=p,p=c):(n(p,c),c=Pi(m,p.mode,_),c.return=p,p=c),i(p)):n(p,c)}return Se}var On=os(!0),ss=os(!1),cl=$t(null),fl=null,Dn=null,Uu=null;function Au(){Uu=Dn=fl=null}function Vu(e){var t=cl.current;fe(cl),e._currentValue=t}function Bu(e,t,n){for(;e!==null;){var r=e.alternate;if((e.childLanes&t)!==t?(e.childLanes|=t,r!==null&&(r.childLanes|=t)):r!==null&&(r.childLanes&t)!==t&&(r.childLanes|=t),e===n)break;e=e.return}}function Mn(e,t){fl=e,Uu=Dn=null,e=e.dependencies,e!==null&&e.firstContext!==null&&((e.lanes&t)!==0&&(qe=!0),e.firstContext=null)}function ct(e){var t=e._currentValue;if(Uu!==e)if(e={context:e,memoizedValue:t,next:null},Dn===null){if(fl===null)throw Error(g(308));Dn=e,fl.dependencies={lanes:0,firstContext:e}}else Dn=Dn.next=e;return t}var on=null;function Hu(e){on===null?on=[e]:on.push(e)}function as(e,t,n,r){var l=t.interleaved;return l===null?(n.next=n,Hu(t)):(n.next=l.next,l.next=n),t.interleaved=n,Rt(e,r)}function Rt(e,t){e.lanes|=t;var n=e.alternate;for(n!==null&&(n.lanes|=t),n=e,e=e.return;e!==null;)e.childLanes|=t,n=e.alternate,n!==null&&(n.childLanes|=t),n=e,e=e.return;return n.tag===3?n.stateNode:null}var Kt=!1;function $u(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null}}function cs(e,t){e=e.updateQueue,t.updateQueue===e&&(t.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,effects:e.effects})}function Ot(e,t){return{eventTime:e,lane:t,tag:0,payload:null,callback:null,next:null}}function Yt(e,t,n){var r=e.updateQueue;if(r===null)return null;if(r=r.shared,(G&2)!==0){var l=r.pending;return l===null?t.next=t:(t.next=l.next,l.next=t),r.pending=t,Rt(e,n)}return l=r.interleaved,l===null?(t.next=t,Hu(r)):(t.next=l.next,l.next=t),r.interleaved=t,Rt(e,n)}function dl(e,t,n){if(t=t.updateQueue,t!==null&&(t=t.shared,(n&4194240)!==0)){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,ru(e,n)}}function fs(e,t){var n=e.updateQueue,r=e.alternate;if(r!==null&&(r=r.updateQueue,n===r)){var l=null,u=null;if(n=n.firstBaseUpdate,n!==null){do{var i={eventTime:n.eventTime,lane:n.lane,tag:n.tag,payload:n.payload,callback:n.callback,next:null};u===null?l=u=i:u=u.next=i,n=n.next}while(n!==null);u===null?l=u=t:u=u.next=t}else l=u=t;n={baseState:r.baseState,firstBaseUpdate:l,lastBaseUpdate:u,shared:r.shared,effects:r.effects},e.updateQueue=n;return}e=n.lastBaseUpdate,e===null?n.firstBaseUpdate=t:e.next=t,n.lastBaseUpdate=t}function pl(e,t,n,r){var l=e.updateQueue;Kt=!1;var u=l.firstBaseUpdate,i=l.lastBaseUpdate,o=l.shared.pending;if(o!==null){l.shared.pending=null;var a=o,h=a.next;a.next=null,i===null?u=h:i.next=h,i=a;var w=e.alternate;w!==null&&(w=w.updateQueue,o=w.lastBaseUpdate,o!==i&&(o===null?w.firstBaseUpdate=h:o.next=h,w.lastBaseUpdate=a))}if(u!==null){var S=l.baseState;i=0,w=h=a=null,o=u;do{var y=o.lane,E=o.eventTime;if((r&y)===y){w!==null&&(w=w.next={eventTime:E,lane:0,tag:o.tag,payload:o.payload,callback:o.callback,next:null});e:{var N=e,P=o;switch(y=t,E=n,P.tag){case 1:if(N=P.payload,typeof N=="function"){S=N.call(E,S,y);break e}S=N;break e;case 3:N.flags=N.flags&-65537|128;case 0:if(N=P.payload,y=typeof N=="function"?N.call(E,S,y):N,y==null)break e;S=k({},S,y);break e;case 2:Kt=!0}}o.callback!==null&&o.lane!==0&&(e.flags|=64,y=l.effects,y===null?l.effects=[o]:y.push(o))}else E={eventTime:E,lane:y,tag:o.tag,payload:o.payload,callback:o.callback,next:null},w===null?(h=w=E,a=S):w=w.next=E,i|=y;if(o=o.next,o===null){if(o=l.shared.pending,o===null)break;y=o,o=y.next,y.next=null,l.lastBaseUpdate=y,l.shared.pending=null}}while(!0);if(w===null&&(a=S),l.baseState=a,l.firstBaseUpdate=h,l.lastBaseUpdate=w,t=l.shared.interleaved,t!==null){l=t;do i|=l.lane,l=l.next;while(l!==t)}else u===null&&(l.shared.lanes=0);cn|=i,e.lanes=i,e.memoizedState=S}}function ds(e,t,n){if(e=t.effects,t.effects=null,e!==null)for(t=0;tn?n:4,e(!0);var r=Xu.transition;Xu.transition={};try{e(!1),t()}finally{te=n,Xu.transition=r}}function zs(){return ft().memoizedState}function uf(e,t,n){var r=Zt(e);if(n={lane:r,action:n,hasEagerState:!1,eagerState:null,next:null},Rs(e))Os(t,n);else if(n=as(e,t,n,r),n!==null){var l=Xe();_t(n,e,r,l),Ds(n,t,r)}}function of(e,t,n){var r=Zt(e),l={lane:r,action:n,hasEagerState:!1,eagerState:null,next:null};if(Rs(e))Os(t,l);else{var u=e.alternate;if(e.lanes===0&&(u===null||u.lanes===0)&&(u=t.lastRenderedReducer,u!==null))try{var i=t.lastRenderedState,o=u(i,n);if(l.hasEagerState=!0,l.eagerState=o,gt(o,i)){var a=t.interleaved;a===null?(l.next=l,Hu(t)):(l.next=a.next,a.next=l),t.interleaved=l;return}}catch{}finally{}n=as(e,t,l,r),n!==null&&(l=Xe(),_t(n,e,r,l),Ds(n,t,r))}}function Rs(e){var t=e.alternate;return e===ve||t!==null&&t===ve}function Os(e,t){wr=vl=!0;var n=e.pending;n===null?t.next=t:(t.next=n.next,n.next=t),e.pending=t}function Ds(e,t,n){if((n&4194240)!==0){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,ru(e,n)}}var wl={readContext:ct,useCallback:$e,useContext:$e,useEffect:$e,useImperativeHandle:$e,useInsertionEffect:$e,useLayoutEffect:$e,useMemo:$e,useReducer:$e,useRef:$e,useState:$e,useDebugValue:$e,useDeferredValue:$e,useTransition:$e,useMutableSource:$e,useSyncExternalStore:$e,useId:$e,unstable_isNewReconciler:!1},sf={readContext:ct,useCallback:function(e,t){return jt().memoizedState=[e,t===void 0?null:t],e},useContext:ct,useEffect:ks,useImperativeHandle:function(e,t,n){return n=n!=null?n.concat([e]):null,gl(4194308,4,js.bind(null,t,e),n)},useLayoutEffect:function(e,t){return gl(4194308,4,e,t)},useInsertionEffect:function(e,t){return gl(4,2,e,t)},useMemo:function(e,t){var n=jt();return t=t===void 0?null:t,e=e(),n.memoizedState=[e,t],e},useReducer:function(e,t,n){var r=jt();return t=n!==void 0?n(t):t,r.memoizedState=r.baseState=t,e={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:t},r.queue=e,e=e.dispatch=uf.bind(null,ve,e),[r.memoizedState,e]},useRef:function(e){var t=jt();return e={current:e},t.memoizedState=e},useState:Ss,useDebugValue:ti,useDeferredValue:function(e){return jt().memoizedState=e},useTransition:function(){var e=Ss(!1),t=e[0];return e=lf.bind(null,e[1]),jt().memoizedState=e,[t,e]},useMutableSource:function(){},useSyncExternalStore:function(e,t,n){var r=ve,l=jt();if(pe){if(n===void 0)throw Error(g(407));n=n()}else{if(n=t(),Oe===null)throw Error(g(349));(an&30)!==0||vs(r,t,n)}l.memoizedState=n;var u={value:n,getSnapshot:t};return l.queue=u,ks(ys.bind(null,r,u,e),[e]),r.flags|=2048,_r(9,gs.bind(null,r,u,n,t),void 0,null),n},useId:function(){var e=jt(),t=Oe.identifierPrefix;if(pe){var n=zt,r=Lt;n=(r&~(1<<32-vt(r)-1)).toString(32)+n,t=":"+t+"R"+n,n=xr++,0<\/script>",e=e.removeChild(e.firstChild)):typeof r.is=="string"?e=i.createElement(n,{is:r.is}):(e=i.createElement(n),n==="select"&&(i=e,r.multiple?i.multiple=!0:r.size&&(i.size=r.size))):e=i.createElementNS(e,n),e[Ct]=t,e[pr]=r,ea(e,t,!1,!1),t.stateNode=e;e:{switch(i=Yl(n,r),n){case"dialog":ce("cancel",e),ce("close",e),l=r;break;case"iframe":case"object":case"embed":ce("load",e),l=r;break;case"video":case"audio":for(l=0;lVn&&(t.flags|=128,r=!0,kr(u,!1),t.lanes=4194304)}else{if(!r)if(e=ml(i),e!==null){if(t.flags|=128,r=!0,n=e.updateQueue,n!==null&&(t.updateQueue=n,t.flags|=4),kr(u,!0),u.tail===null&&u.tailMode==="hidden"&&!i.alternate&&!pe)return Qe(t),null}else 2*xe()-u.renderingStartTime>Vn&&n!==1073741824&&(t.flags|=128,r=!0,kr(u,!1),t.lanes=4194304);u.isBackwards?(i.sibling=t.child,t.child=i):(n=u.last,n!==null?n.sibling=i:t.child=i,u.last=i)}return u.tail!==null?(t=u.tail,u.rendering=t,u.tail=t.sibling,u.renderingStartTime=xe(),t.sibling=null,n=he.current,se(he,r?n&1|2:n&1),t):(Qe(t),null);case 22:case 23:return Ei(),r=t.memoizedState!==null,e!==null&&e.memoizedState!==null!==r&&(t.flags|=8192),r&&(t.mode&1)!==0?(it&1073741824)!==0&&(Qe(t),t.subtreeFlags&6&&(t.flags|=8192)):Qe(t),null;case 24:return null;case 25:return null}throw Error(g(156,t.tag))}function vf(e,t){switch(Du(t),t.tag){case 1:return Ze(t.type)&&rl(),e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 3:return In(),fe(Je),fe(He),Yu(),e=t.flags,(e&65536)!==0&&(e&128)===0?(t.flags=e&-65537|128,t):null;case 5:return Wu(t),null;case 13:if(fe(he),e=t.memoizedState,e!==null&&e.dehydrated!==null){if(t.alternate===null)throw Error(g(340));Rn()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 19:return fe(he),null;case 4:return In(),null;case 10:return Vu(t.type._context),null;case 22:case 23:return Ei(),null;case 24:return null;default:return null}}var kl=!1,We=!1,gf=typeof WeakSet=="function"?WeakSet:Set,j=null;function Un(e,t){var n=e.ref;if(n!==null)if(typeof n=="function")try{n(null)}catch(r){ye(e,t,r)}else n.current=null}function pi(e,t,n){try{n()}catch(r){ye(e,t,r)}}var ra=!1;function yf(e,t){if(Eu=$r,e=Mo(),gu(e)){if("selectionStart"in e)var n={start:e.selectionStart,end:e.selectionEnd};else e:{n=(n=e.ownerDocument)&&n.defaultView||window;var r=n.getSelection&&n.getSelection();if(r&&r.rangeCount!==0){n=r.anchorNode;var l=r.anchorOffset,u=r.focusNode;r=r.focusOffset;try{n.nodeType,u.nodeType}catch{n=null;break e}var i=0,o=-1,a=-1,h=0,w=0,S=e,y=null;t:for(;;){for(var E;S!==n||l!==0&&S.nodeType!==3||(o=i+l),S!==u||r!==0&&S.nodeType!==3||(a=i+r),S.nodeType===3&&(i+=S.nodeValue.length),(E=S.firstChild)!==null;)y=S,S=E;for(;;){if(S===e)break t;if(y===n&&++h===l&&(o=i),y===u&&++w===r&&(a=i),(E=S.nextSibling)!==null)break;S=y,y=S.parentNode}S=E}n=o===-1||a===-1?null:{start:o,end:a}}else n=null}n=n||{start:0,end:0}}else n=null;for(ju={focusedElem:e,selectionRange:n},$r=!1,j=t;j!==null;)if(t=j,e=t.child,(t.subtreeFlags&1028)!==0&&e!==null)e.return=t,j=e;else for(;j!==null;){t=j;try{var N=t.alternate;if((t.flags&1024)!==0)switch(t.tag){case 0:case 11:case 15:break;case 1:if(N!==null){var P=N.memoizedProps,Se=N.memoizedState,p=t.stateNode,c=p.getSnapshotBeforeUpdate(t.elementType===t.type?P:wt(t.type,P),Se);p.__reactInternalSnapshotBeforeUpdate=c}break;case 3:var m=t.stateNode.containerInfo;m.nodeType===1?m.textContent="":m.nodeType===9&&m.documentElement&&m.removeChild(m.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(g(163))}}catch(_){ye(t,t.return,_)}if(e=t.sibling,e!==null){e.return=t.return,j=e;break}j=t.return}return N=ra,ra=!1,N}function Cr(e,t,n){var r=t.updateQueue;if(r=r!==null?r.lastEffect:null,r!==null){var l=r=r.next;do{if((l.tag&e)===e){var u=l.destroy;l.destroy=void 0,u!==void 0&&pi(t,n,u)}l=l.next}while(l!==r)}}function Cl(e,t){if(t=t.updateQueue,t=t!==null?t.lastEffect:null,t!==null){var n=t=t.next;do{if((n.tag&e)===e){var r=n.create;n.destroy=r()}n=n.next}while(n!==t)}}function mi(e){var t=e.ref;if(t!==null){var n=e.stateNode;switch(e.tag){case 5:e=n;break;default:e=n}typeof t=="function"?t(e):t.current=e}}function la(e){var t=e.alternate;t!==null&&(e.alternate=null,la(t)),e.child=null,e.deletions=null,e.sibling=null,e.tag===5&&(t=e.stateNode,t!==null&&(delete t[Ct],delete t[pr],delete t[Lu],delete t[bc],delete t[ef])),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}function ua(e){return e.tag===5||e.tag===3||e.tag===4}function ia(e){e:for(;;){for(;e.sibling===null;){if(e.return===null||ua(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;e.tag!==5&&e.tag!==6&&e.tag!==18;){if(e.flags&2||e.child===null||e.tag===4)continue e;e.child.return=e,e=e.child}if(!(e.flags&2))return e.stateNode}}function hi(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?n.nodeType===8?n.parentNode.insertBefore(e,t):n.insertBefore(e,t):(n.nodeType===8?(t=n.parentNode,t.insertBefore(e,n)):(t=n,t.appendChild(e)),n=n._reactRootContainer,n!=null||t.onclick!==null||(t.onclick=tl));else if(r!==4&&(e=e.child,e!==null))for(hi(e,t,n),e=e.sibling;e!==null;)hi(e,t,n),e=e.sibling}function vi(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?n.insertBefore(e,t):n.appendChild(e);else if(r!==4&&(e=e.child,e!==null))for(vi(e,t,n),e=e.sibling;e!==null;)vi(e,t,n),e=e.sibling}var Ue=null,xt=!1;function Xt(e,t,n){for(n=n.child;n!==null;)oa(e,t,n),n=n.sibling}function oa(e,t,n){if(kt&&typeof kt.onCommitFiberUnmount=="function")try{kt.onCommitFiberUnmount(Fr,n)}catch{}switch(n.tag){case 5:We||Un(n,t);case 6:var r=Ue,l=xt;Ue=null,Xt(e,t,n),Ue=r,xt=l,Ue!==null&&(xt?(e=Ue,n=n.stateNode,e.nodeType===8?e.parentNode.removeChild(n):e.removeChild(n)):Ue.removeChild(n.stateNode));break;case 18:Ue!==null&&(xt?(e=Ue,n=n.stateNode,e.nodeType===8?Tu(e.parentNode,n):e.nodeType===1&&Tu(e,n),nr(e)):Tu(Ue,n.stateNode));break;case 4:r=Ue,l=xt,Ue=n.stateNode.containerInfo,xt=!0,Xt(e,t,n),Ue=r,xt=l;break;case 0:case 11:case 14:case 15:if(!We&&(r=n.updateQueue,r!==null&&(r=r.lastEffect,r!==null))){l=r=r.next;do{var u=l,i=u.destroy;u=u.tag,i!==void 0&&((u&2)!==0||(u&4)!==0)&&pi(n,t,i),l=l.next}while(l!==r)}Xt(e,t,n);break;case 1:if(!We&&(Un(n,t),r=n.stateNode,typeof r.componentWillUnmount=="function"))try{r.props=n.memoizedProps,r.state=n.memoizedState,r.componentWillUnmount()}catch(o){ye(n,t,o)}Xt(e,t,n);break;case 21:Xt(e,t,n);break;case 22:n.mode&1?(We=(r=We)||n.memoizedState!==null,Xt(e,t,n),We=r):Xt(e,t,n);break;default:Xt(e,t,n)}}function sa(e){var t=e.updateQueue;if(t!==null){e.updateQueue=null;var n=e.stateNode;n===null&&(n=e.stateNode=new gf),t.forEach(function(r){var l=Nf.bind(null,e,r);n.has(r)||(n.add(r),r.then(l,l))})}}function St(e,t){var n=t.deletions;if(n!==null)for(var r=0;rl&&(l=i),r&=~u}if(r=l,r=xe()-r,r=(120>r?120:480>r?480:1080>r?1080:1920>r?1920:3e3>r?3e3:4320>r?4320:1960*xf(r/1960))-r,10e?16:e,Jt===null)var r=!1;else{if(e=Jt,Jt=null,Tl=0,(G&6)!==0)throw Error(g(331));var l=G;for(G|=4,j=e.current;j!==null;){var u=j,i=u.child;if((j.flags&16)!==0){var o=u.deletions;if(o!==null){for(var a=0;axe()-wi?dn(e,0):yi|=n),et(e,t)}function Sa(e,t){t===0&&((e.mode&1)===0?t=1:(t=Ar,Ar<<=1,(Ar&130023424)===0&&(Ar=4194304)));var n=Xe();e=Rt(e,t),e!==null&&(Zn(e,t,n),et(e,n))}function jf(e){var t=e.memoizedState,n=0;t!==null&&(n=t.retryLane),Sa(e,n)}function Nf(e,t){var n=0;switch(e.tag){case 13:var r=e.stateNode,l=e.memoizedState;l!==null&&(n=l.retryLane);break;case 19:r=e.stateNode;break;default:throw Error(g(314))}r!==null&&r.delete(t),Sa(e,n)}var _a;_a=function(e,t,n){if(e!==null)if(e.memoizedProps!==t.pendingProps||Je.current)qe=!0;else{if((e.lanes&n)===0&&(t.flags&128)===0)return qe=!1,mf(e,t,n);qe=(e.flags&131072)!==0}else qe=!1,pe&&(t.flags&1048576)!==0&&ts(t,ol,t.index);switch(t.lanes=0,t.tag){case 2:var r=t.type;_l(e,t),e=t.pendingProps;var l=Tn(t,He.current);Mn(t,n),l=Ju(null,t,r,e,l,n);var u=Zu();return t.flags|=1,typeof l=="object"&&l!==null&&typeof l.render=="function"&&l.$$typeof===void 0?(t.tag=1,t.memoizedState=null,t.updateQueue=null,Ze(r)?(u=!0,ll(t)):u=!1,t.memoizedState=l.state!==null&&l.state!==void 0?l.state:null,$u(t),l.updater=xl,t.stateNode=l,l._reactInternals=t,ri(t,r,e,n),t=oi(null,t,r,!0,u,n)):(t.tag=0,pe&&u&&Ou(t),Ye(null,t,l,n),t=t.child),t;case 16:r=t.elementType;e:{switch(_l(e,t),e=t.pendingProps,l=r._init,r=l(r._payload),t.type=r,l=t.tag=Tf(r),e=wt(r,e),l){case 0:t=ii(null,t,r,e,n);break e;case 1:t=Xs(null,t,r,e,n);break e;case 11:t=$s(null,t,r,e,n);break e;case 14:t=Qs(null,t,r,wt(r.type,e),n);break e}throw Error(g(306,r,""))}return t;case 0:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:wt(r,l),ii(e,t,r,l,n);case 1:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:wt(r,l),Xs(e,t,r,l,n);case 3:e:{if(Gs(t),e===null)throw Error(g(387));r=t.pendingProps,u=t.memoizedState,l=u.element,cs(e,t),pl(t,r,null,n);var i=t.memoizedState;if(r=i.element,u.isDehydrated)if(u={element:r,isDehydrated:!1,cache:i.cache,pendingSuspenseBoundaries:i.pendingSuspenseBoundaries,transitions:i.transitions},t.updateQueue.baseState=u,t.memoizedState=u,t.flags&256){l=Fn(Error(g(423)),t),t=Js(e,t,r,n,l);break e}else if(r!==l){l=Fn(Error(g(424)),t),t=Js(e,t,r,n,l);break e}else for(ut=Ht(t.stateNode.containerInfo.firstChild),lt=t,pe=!0,yt=null,n=ss(t,null,r,n),t.child=n;n;)n.flags=n.flags&-3|4096,n=n.sibling;else{if(Rn(),r===l){t=Dt(e,t,n);break e}Ye(e,t,r,n)}t=t.child}return t;case 5:return ps(t),e===null&&Iu(t),r=t.type,l=t.pendingProps,u=e!==null?e.memoizedProps:null,i=l.children,Nu(r,l)?i=null:u!==null&&Nu(r,u)&&(t.flags|=32),Ys(e,t),Ye(e,t,i,n),t.child;case 6:return e===null&&Iu(t),null;case 13:return Zs(e,t,n);case 4:return Qu(t,t.stateNode.containerInfo),r=t.pendingProps,e===null?t.child=On(t,null,r,n):Ye(e,t,r,n),t.child;case 11:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:wt(r,l),$s(e,t,r,l,n);case 7:return Ye(e,t,t.pendingProps,n),t.child;case 8:return Ye(e,t,t.pendingProps.children,n),t.child;case 12:return Ye(e,t,t.pendingProps.children,n),t.child;case 10:e:{if(r=t.type._context,l=t.pendingProps,u=t.memoizedProps,i=l.value,se(cl,r._currentValue),r._currentValue=i,u!==null)if(gt(u.value,i)){if(u.children===l.children&&!Je.current){t=Dt(e,t,n);break e}}else for(u=t.child,u!==null&&(u.return=t);u!==null;){var o=u.dependencies;if(o!==null){i=u.child;for(var a=o.firstContext;a!==null;){if(a.context===r){if(u.tag===1){a=Ot(-1,n&-n),a.tag=2;var h=u.updateQueue;if(h!==null){h=h.shared;var w=h.pending;w===null?a.next=a:(a.next=w.next,w.next=a),h.pending=a}}u.lanes|=n,a=u.alternate,a!==null&&(a.lanes|=n),Bu(u.return,n,t),o.lanes|=n;break}a=a.next}}else if(u.tag===10)i=u.type===t.type?null:u.child;else if(u.tag===18){if(i=u.return,i===null)throw Error(g(341));i.lanes|=n,o=i.alternate,o!==null&&(o.lanes|=n),Bu(i,n,t),i=u.sibling}else i=u.child;if(i!==null)i.return=u;else for(i=u;i!==null;){if(i===t){i=null;break}if(u=i.sibling,u!==null){u.return=i.return,i=u;break}i=i.return}u=i}Ye(e,t,l.children,n),t=t.child}return t;case 9:return l=t.type,r=t.pendingProps.children,Mn(t,n),l=ct(l),r=r(l),t.flags|=1,Ye(e,t,r,n),t.child;case 14:return r=t.type,l=wt(r,t.pendingProps),l=wt(r.type,l),Qs(e,t,r,l,n);case 15:return Ws(e,t,t.type,t.pendingProps,n);case 17:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:wt(r,l),_l(e,t),t.tag=1,Ze(r)?(e=!0,ll(t)):e=!1,Mn(t,n),Is(t,r,l),ri(t,r,l,n),oi(null,t,r,!0,e,n);case 19:return bs(e,t,n);case 22:return Ks(e,t,n)}throw Error(g(156,t.tag))};function ka(e,t){return to(e,t)}function Pf(e,t,n,r){this.tag=e,this.key=n,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.ref=null,this.pendingProps=t,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=r,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function pt(e,t,n,r){return new Pf(e,t,n,r)}function Ni(e){return e=e.prototype,!(!e||!e.isReactComponent)}function Tf(e){if(typeof e=="function")return Ni(e)?1:0;if(e!=null){if(e=e.$$typeof,e===ze)return 11;if(e===Ce)return 14}return 2}function bt(e,t){var n=e.alternate;return n===null?(n=pt(e.tag,t,e.key,e.mode),n.elementType=e.elementType,n.type=e.type,n.stateNode=e.stateNode,n.alternate=e,e.alternate=n):(n.pendingProps=t,n.type=e.type,n.flags=0,n.subtreeFlags=0,n.deletions=null),n.flags=e.flags&14680064,n.childLanes=e.childLanes,n.lanes=e.lanes,n.child=e.child,n.memoizedProps=e.memoizedProps,n.memoizedState=e.memoizedState,n.updateQueue=e.updateQueue,t=e.dependencies,n.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext},n.sibling=e.sibling,n.index=e.index,n.ref=e.ref,n}function Ol(e,t,n,r,l,u){var i=2;if(r=e,typeof e=="function")Ni(e)&&(i=1);else if(typeof e=="string")i=5;else e:switch(e){case je:return mn(n.children,l,u,t);case Ve:i=8,l|=8;break;case ge:return e=pt(12,n,t,l|2),e.elementType=ge,e.lanes=u,e;case Be:return e=pt(13,n,t,l),e.elementType=Be,e.lanes=u,e;case nt:return e=pt(19,n,t,l),e.elementType=nt,e.lanes=u,e;case ae:return Dl(n,l,u,t);default:if(typeof e=="object"&&e!==null)switch(e.$$typeof){case ht:i=10;break e;case ot:i=9;break e;case ze:i=11;break e;case Ce:i=14;break e;case we:i=16,r=null;break e}throw Error(g(130,e==null?e:typeof e,""))}return t=pt(i,n,t,l),t.elementType=e,t.type=r,t.lanes=u,t}function mn(e,t,n,r){return e=pt(7,e,r,t),e.lanes=n,e}function Dl(e,t,n,r){return e=pt(22,e,r,t),e.elementType=ae,e.lanes=n,e.stateNode={isHidden:!1},e}function Pi(e,t,n){return e=pt(6,e,null,t),e.lanes=n,e}function Ti(e,t,n){return t=pt(4,e.children!==null?e.children:[],e.key,t),t.lanes=n,t.stateNode={containerInfo:e.containerInfo,pendingChildren:null,implementation:e.implementation},t}function Lf(e,t,n,r,l){this.tag=t,this.containerInfo=e,this.finishedWork=this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.pendingContext=this.context=null,this.callbackPriority=0,this.eventTimes=nu(0),this.expirationTimes=nu(-1),this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=nu(0),this.identifierPrefix=r,this.onRecoverableError=l,this.mutableSourceEagerHydrationData=null}function Li(e,t,n,r,l,u,i,o,a){return e=new Lf(e,t,n,o,a),t===1?(t=1,u===!0&&(t|=8)):t=0,u=pt(3,null,null,t),e.current=u,u.stateNode=e,u.memoizedState={element:r,isDehydrated:n,cache:null,transitions:null,pendingSuspenseBoundaries:null},$u(u),e}function zf(e,t,n){var r=3"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(x)}catch(R){console.error(R)}}return x(),Ii.exports=$f(),Ii.exports}var Fa;function Wf(){if(Fa)return Bl;Fa=1;var x=Qf();return Bl.createRoot=x.createRoot,Bl.hydrateRoot=x.hydrateRoot,Bl}var Kf=Wf();const Yf=Aa(Kf),Ql={name:"",country_code:"US",campaign_type:"custom",campaign_state:"",campaign_subtype:"",campaign_language:"en",segment_by:"custom",locate_by:"",include_special:"",target_ordering:"",target_shuffle_chamber:!0,target_offices:"",call_maximum:"",allow_call_in:!1,allow_intl_calls:!1,prompt_schedule:!1,status_code:1,phone_number_ids:[],target_ids:[],embed_type:"",embed_script:"",embed_form_sel:"",embed_phone_sel:"",embed_location_sel:"",embed_custom_css:"",embed_custom_js:"",embed_custom_onload:"",embed_script_display:"",embed_phone_display:"",embed_redirect:"",crm_sync:!1,crm_id:"",crm_key:"",sync_schedule:"hourly"},Xf=[{value:0,label:"Archived"},{value:1,label:"Paused"},{value:2,label:"Live"}],Gf=[{value:"custom",label:"Custom"},{value:"local",label:"Local"},{value:"state",label:"State"},{value:"congress",label:"Congress"},{value:"executive",label:"Executive"}],Jf=[{value:"custom",label:"Custom"},{value:"location",label:"Location"}],Zf=[{value:"",label:"None"},{value:"iframe",label:"iFrame"},{value:"custom",label:"Javascript"}],qf=[{value:"",label:"None"},{value:"overlay",label:"Overlay"},{value:"alert",label:"Alert"},{value:"replace",label:"Replace Form"},{value:"redirect",label:"Redirect URL"},{value:"custom",label:"Custom"}],bf=[{value:"hourly",label:"Hourly"},{value:"nightly",label:"Nightly"},{value:"immediate",label:"Immediate"}];function Hl({label:x,value:R}){return s.jsxs("section",{className:"stat-card",children:[s.jsx("p",{children:x}),s.jsx("strong",{children:R})]})}function ed({credentials:x,loginState:R,onChange:g,onSubmit:W}){return s.jsx("main",{className:"login-page",children:s.jsxs("section",{className:"panel login-panel",children:[s.jsxs("div",{className:"panel-header",children:[s.jsxs("div",{children:[s.jsx("span",{className:"eyebrow",children:"Django auth"}),s.jsx("h2",{children:"Sign in"})]}),R.message?s.jsx("p",{className:`status-message status-${R.status}`,children:R.message}):s.jsx("p",{children:"Use your existing Call Power username or email and password."})]}),s.jsxs("form",{className:"editor-form",onSubmit:W,children:[s.jsx(H,{label:"Username or email",children:s.jsx("input",{autoComplete:"username",onChange:A=>g("login",A.target.value),type:"text",value:x.login})}),s.jsx(H,{label:"Password",children:s.jsx("input",{autoComplete:"current-password",onChange:A=>g("password",A.target.value),type:"password",value:x.password})}),s.jsx("div",{className:"form-actions",children:s.jsx("button",{className:"button button-accent",type:"submit",children:"Sign in"})})]})]})})}function td({campaign:x,isActive:R,onSelect:g}){return s.jsxs("tr",{className:R?"active-row":"",onClick:()=>g(x.id),children:[s.jsx("td",{children:x.name}),s.jsx("td",{children:x.campaign_type||"Custom"}),s.jsx("td",{children:x.country_code||"US"}),s.jsx("td",{children:x.completed_calls}),s.jsx("td",{children:x.total_sessions}),s.jsx("td",{children:x.active_scheduled_calls})]})}function H({label:x,children:R}){return s.jsxs("label",{className:"field",children:[s.jsx("span",{children:x}),R]})}function nd({audioVersions:x,audioForm:R,audioState:g,onAudioFieldChange:W,onAudioUpload:A,onAudioAction:F}){return s.jsxs("section",{className:"panel audio-panel",children:[s.jsxs("div",{className:"panel-header",children:[s.jsxs("div",{children:[s.jsx("span",{className:"eyebrow",children:"Audio"}),s.jsx("h2",{children:"Prompt versions"})]}),g.message?s.jsx("p",{className:`status-message status-${g.status}`,children:g.message}):s.jsx("p",{children:"Upload a new prompt or manage existing versions for this campaign."})]}),s.jsxs("form",{className:"editor-form",onSubmit:A,children:[s.jsxs("div",{className:"field-grid",children:[s.jsx(H,{label:"Prompt key",children:s.jsx("select",{onChange:T=>W("key",T.target.value),value:R.key,children:["msg_intro","msg_intro_confirm","msg_location","msg_invalid_location","msg_unparsed_location","msg_prompt_schedule","msg_alter_schedule","msg_schedule_start","msg_schedule_stop","msg_call_block_intro","msg_target_intro","msg_target_busy","msg_between_calls","msg_final_thanks","msg_campaign_complete"].map(T=>s.jsx("option",{value:T,children:T},T))})}),s.jsx(H,{label:"Description",children:s.jsx("input",{onChange:T=>W("description",T.target.value),type:"text",value:R.description})})]}),s.jsx(H,{label:"Text to speech",children:s.jsx("textarea",{onChange:T=>W("text_to_speech",T.target.value),rows:"3",value:R.text_to_speech})}),s.jsx(H,{label:"Audio file",children:s.jsx("input",{accept:".mp3,.wav,audio/mpeg,audio/wav,audio/x-wav",onChange:T=>{var b;return W("file_storage",((b=T.target.files)==null?void 0:b[0])??null)},type:"file"})}),s.jsx("div",{className:"form-actions",children:s.jsx("button",{className:"button button-accent",type:"submit",children:"Upload version"})})]}),s.jsx("div",{className:"audio-list",children:x.length===0?s.jsx("p",{className:"empty-state",children:"No audio versions yet for this campaign."}):x.map(T=>s.jsxs("article",{className:`audio-card ${T.selected?"audio-card-selected":""}`,children:[s.jsxs("div",{className:"audio-card-header",children:[s.jsxs("div",{children:[s.jsx("strong",{children:T.key}),s.jsxs("p",{children:["Version ",T.version]})]}),s.jsxs("div",{className:"audio-badges",children:[T.selected?s.jsx("span",{className:"badge badge-active",children:"Selected"}):null,T.hidden?s.jsx("span",{className:"badge",children:"Hidden"}):null]})]}),s.jsx("p",{children:T.description||"No description"}),T.text_to_speech?s.jsx("pre",{className:"audio-copy",children:T.text_to_speech}):null,T.file_url?s.jsx("audio",{controls:!0,src:T.file_url,children:s.jsx("track",{kind:"captions"})}):null,s.jsxs("div",{className:"audio-actions",children:[s.jsx("button",{className:"button",onClick:()=>F(T.id,"select"),type:"button",children:"Select"}),s.jsx("button",{className:"button",onClick:()=>F(T.id,T.hidden?"show":"hide"),type:"button",children:T.hidden?"Show":"Hide"})]})]},T.id))})]})}function $l(x){var R,g;return x?{...Ql,...x,call_maximum:x.call_maximum??"",phone_number_ids:x.phone_number_ids??((R=x.assigned_phone_numbers)==null?void 0:R.map(W=>W.id))??[],target_ids:x.target_ids??((g=x.assigned_targets)==null?void 0:g.map(W=>W.id))??[]}:Ql}function Ua(x){if(typeof window>"u")return x;const R=x.startsWith("/")?x:`/${x}`,{protocol:g,hostname:W,port:A}=window.location;return A==="5173"?`${g}//${W}:8000${R}`:R}async function Me(x,R={}){const g={...R.headers||{}};!(R.body instanceof FormData)&&!g["Content-Type"]&&(g["Content-Type"]="application/json");const W=await fetch(x,{credentials:"include",headers:g,...R}),A=W.headers.get("content-type")||"";let F=null;if(A.includes("application/json")&&(F=await W.json()),!W.ok){const T=(F==null?void 0:F.error)||(F==null?void 0:F.detail)||(F==null?void 0:F.message)||`${W.status} ${W.statusText}`,b=new Error(T);throw b.status=W.status,b.data=F,b}return F}function rd(){var $n,gn;const[x,R]=de.useState({checked:!1,authenticated:!1,user:null}),[g,W]=de.useState({login:"",password:""}),[A,F]=de.useState({status:"idle",message:""}),[T,b]=de.useState(null),[ee,_e]=de.useState([]),[Te,le]=de.useState([]),[ie,Ie]=de.useState([]),[Fe,oe]=de.useState(""),[J,mt]=de.useState(""),[Y,ke]=de.useState(null),[O,Le]=de.useState(Ql),[ne,je]=de.useState(!1),[Ve,ge]=de.useState({status:"idle",message:""}),[ht,ot]=de.useState([]),[ze,Be]=de.useState({key:"msg_intro",description:"",text_to_speech:"",file_storage:null}),[nt,Ce]=de.useState({status:"idle",message:""}),[we,ae]=de.useState({userPhone:"",userLocation:"",userCountry:"US",record:!1}),[C,z]=de.useState({status:"idle",message:""});function k(f,I){if(f.status===401){R({checked:!0,authenticated:!1,user:null}),F({status:"error",message:"Your session expired. Sign in again."}),b(null),_e([]),le([]),Ie([]),ke(null);return}I({status:"error",message:f.message})}async function d(){const[f,I,$,me]=await Promise.all([Me("/api/dashboard/summary/"),Me("/api/campaigns/"),Me("/api/phone-numbers/"),Me("/api/targets/")]);b(f),_e(I.results),le($.results),Ie(me.results),!Y&&I.results.length>0&&ke(I.results[0].id)}de.useEffect(()=>{Me("/auth/me/").then(f=>{R({checked:!0,authenticated:!0,user:f.user})}).catch(()=>{R({checked:!0,authenticated:!1,user:null})})},[]),de.useEffect(()=>{x.authenticated&&d().catch(f=>{k(f,ge)})},[x.authenticated]),de.useEffect(()=>{if(!x.authenticated)return;const f=new AbortController;async function I(){var Qn;const me=Fe?`?q=${encodeURIComponent(Fe)}`:"",Ge=await Me(`/api/campaigns/${me}`,{signal:f.signal});_e(Ge.results),Ge.results.find(Rr=>Rr.id===Y)||ke(((Qn=Ge.results[0])==null?void 0:Qn.id)??null)}const $=window.setTimeout(()=>{I().catch(me=>{me.name!=="AbortError"&&k(me,ge)})},150);return()=>{f.abort(),window.clearTimeout($)}},[x.authenticated,Fe]),de.useEffect(()=>{!x.authenticated||!Y||ne||Me(`/api/campaigns/${Y}/`).then(f=>{Le($l(f)),ae(I=>({...I,userCountry:(f.country_code||"US").toUpperCase()})),ge({status:"idle",message:""})}).catch(f=>{k(f,ge)})},[x.authenticated,Y,ne]),de.useEffect(()=>{if(!x.authenticated||!Y||ne){ot([]);return}Me(`/api/campaigns/${Y}/audio/`).then(f=>{ot(f.results),Ce({status:"idle",message:""})}).catch(f=>{k(f,Ce)})},[x.authenticated,Y,ne]),de.useEffect(()=>{if(!x.authenticated)return;const f=new AbortController;async function I(){const me=J?`?q=${encodeURIComponent(J)}`:"",Ge=await Me(`/api/targets/${me}`,{signal:f.signal});Ie(Ge.results)}const $=window.setTimeout(()=>{I().catch(me=>{me.name!=="AbortError"&&k(me,ge)})},150);return()=>{f.abort(),window.clearTimeout($)}},[x.authenticated,J]);function v(f,I){Le($=>({...$,[f]:I}))}function V(f,I){W($=>({...$,[f]:I}))}function B(f,I){Be($=>({...$,[f]:I}))}function K(f,I){ae($=>({...$,[f]:I}))}function X(){je(!0),ke(null),Le(Ql),ge({status:"idle",message:""})}async function re(f){f.preventDefault(),ge({status:"saving",message:"Saving..."});const I={...O,call_maximum:O.call_maximum===""?null:Number(O.call_maximum),status_code:Number(O.status_code)};try{const $=ne?await Me("/api/campaigns/",{method:"POST",body:JSON.stringify(I)}):await Me(`/api/campaigns/${Y}/`,{method:"PATCH",body:JSON.stringify(I)});Le($l($)),je(!1),ke($.id),ge({status:"success",message:"Campaign saved."}),await d()}catch($){k($,ge)}}async function q(){if(Y){ge({status:"saving",message:"Copying..."});try{const f=await Me(`/api/campaigns/${Y}/copy/`,{method:"POST"});je(!1),ke(f.id),Le($l(f)),ge({status:"success",message:"Campaign copied."}),await d()}catch(f){k(f,ge)}}}async function ue(){if(!Y)return;const f=await Me(`/api/campaigns/${Y}/audio/`);ot(f.results)}async function Ke(f){if(f.preventDefault(),!Y)return;Ce({status:"saving",message:"Uploading..."});const I=new FormData;I.append("key",ze.key),I.append("description",ze.description),ze.text_to_speech&&I.append("text_to_speech",ze.text_to_speech),ze.file_storage&&I.append("file_storage",ze.file_storage);try{const $=await fetch(`/api/campaigns/${Y}/audio/upload/`,{credentials:"include",method:"POST",body:I}),me=await $.json();if(!$.ok){const Ge=new Error(me.error||me.detail||me.message||"Upload failed");throw Ge.status=$.status,Ge}Be(Ge=>({...Ge,description:"",text_to_speech:"",file_storage:null})),await ue(),Ce({status:"success",message:me.message})}catch($){k($,Ce)}}async function hn(f,I){if(Y){Ce({status:"saving",message:`${I}...`});try{const $=await Me(`/api/campaigns/${Y}/audio/${f}/${I}/`,{method:"POST"});await ue(),Ce({status:"success",message:$.message})}catch($){k($,Ce)}}}async function Lr(){if(Y){z({status:"saving",message:"Launching..."});try{const f=await Me(`/api/campaigns/${Y}/launch/`,{method:"POST"});Le($l(f.campaign)),z({status:"success",message:f.message}),await d()}catch(f){k(f,z)}}}async function vn(f){if(f.preventDefault(),!!Y){z({status:"saving",message:"Placing test call..."});try{const I=await Me(`/api/campaigns/${Y}/test-call/`,{method:"POST",body:JSON.stringify(we)});I.call==="queued"?z({status:"success",message:`Calling ${we.userPhone} now.`}):z({status:"error",message:I.error||"Unable to place call"})}catch(I){k(I,z)}}}async function Hn(f){f.preventDefault(),F({status:"saving",message:"Signing in..."});try{const I=await Me("/auth/login/",{method:"POST",body:JSON.stringify(g)});R({checked:!0,authenticated:!0,user:I.user}),W({login:"",password:""}),F({status:"success",message:"Signed in."})}catch(I){F({status:"error",message:I.message})}}async function zr(){try{await Me("/auth/logout/",{method:"POST"})}finally{R({checked:!0,authenticated:!1,user:null}),b(null),_e([]),le([]),Ie([]),ke(null),ot([]),F({status:"idle",message:""}),ge({status:"idle",message:""}),Ce({status:"idle",message:""}),z({status:"idle",message:""})}}return x.checked?x.authenticated?s.jsxs("main",{className:"page",children:[s.jsxs("header",{className:"hero",children:[s.jsxs("div",{children:[s.jsx("span",{className:"eyebrow",children:"Django + React migration"}),s.jsx("h1",{children:"Call Power Admin"}),s.jsx("p",{children:"This admin slice now supports campaign browsing and basic campaign editing from the new stack while the legacy Flask app still handles the deeper workflows."})]}),s.jsxs("div",{className:"hero-actions",children:[s.jsxs("p",{className:"session-label",children:["Signed in as ",($n=x.user)==null?void 0:$n.name]}),s.jsxs("div",{className:"account-links",children:[s.jsx("a",{className:"button",href:Ua("/user/profile"),children:"Profile"}),((gn=x.user)==null?void 0:gn.role_code)===0?s.jsx("a",{className:"button",href:Ua("/admin/user"),children:"Manage Users"}):null]}),s.jsx("input",{"aria-label":"Search campaigns",className:"search",onChange:f=>oe(f.target.value),placeholder:"Search campaigns",value:Fe}),s.jsx("button",{className:"button button-accent",onClick:X,type:"button",children:"New Campaign"}),s.jsx("button",{className:"button",onClick:zr,type:"button",children:"Sign out"})]})]}),s.jsxs("section",{className:"stats-grid",children:[s.jsx(Hl,{label:"Campaigns",value:(T==null?void 0:T.campaigns)??"..."}),s.jsx(Hl,{label:"Completed Calls This Month",value:(T==null?void 0:T.completed_calls_this_month)??"..."}),s.jsx(Hl,{label:"Scheduled Calls",value:(T==null?void 0:T.scheduled_calls)??"..."}),s.jsx(Hl,{label:"Users",value:(T==null?void 0:T.users)??"..."})]}),s.jsxs("section",{className:"workspace",children:[s.jsxs("section",{className:"panel",children:[s.jsxs("div",{className:"panel-header",children:[s.jsxs("div",{children:[s.jsx("span",{className:"eyebrow",children:"Campaigns"}),s.jsx("h2",{children:"Activity"})]}),s.jsx("p",{children:"Click a campaign to load it into the editor."})]}),s.jsxs("table",{children:[s.jsx("thead",{children:s.jsxs("tr",{children:[s.jsx("th",{children:"Name"}),s.jsx("th",{children:"Type"}),s.jsx("th",{children:"Country"}),s.jsx("th",{children:"Completed Calls"}),s.jsx("th",{children:"Sessions"}),s.jsx("th",{children:"Scheduled"})]})}),s.jsx("tbody",{children:ee.map(f=>s.jsx(td,{campaign:f,isActive:f.id===Y&&!ne,onSelect:I=>{je(!1),ke(I)}},f.id))})]})]}),s.jsxs("section",{className:"panel",children:[s.jsxs("div",{className:"panel-header",children:[s.jsxs("div",{children:[s.jsx("span",{className:"eyebrow",children:ne?"Create":"Edit"}),s.jsx("h2",{children:ne?"New campaign":O.name||"Campaign editor"})]}),s.jsxs("div",{className:"editor-actions",children:[!ne&&Y?s.jsx("button",{className:"button",onClick:q,type:"button",children:"Copy Campaign"}):null,Ve.message?s.jsx("p",{className:`status-message status-${Ve.status}`,children:Ve.message}):null]})]}),s.jsxs("form",{className:"editor-form",onSubmit:re,children:[s.jsx(H,{label:"Campaign name",children:s.jsx("input",{onChange:f=>v("name",f.target.value),required:!0,type:"text",value:O.name})}),s.jsxs("div",{className:"field-grid",children:[s.jsx(H,{label:"Country",children:s.jsx("input",{maxLength:2,onChange:f=>v("country_code",f.target.value.toUpperCase()),type:"text",value:O.country_code})}),s.jsx(H,{label:"Language",children:s.jsx("input",{maxLength:2,onChange:f=>v("campaign_language",f.target.value.toLowerCase()),type:"text",value:O.campaign_language})}),s.jsx(H,{label:"Type",children:s.jsx("select",{onChange:f=>v("campaign_type",f.target.value),value:O.campaign_type,children:Gf.map(f=>s.jsx("option",{value:f.value,children:f.label},f.value))})}),s.jsx(H,{label:"Status",children:s.jsx("select",{onChange:f=>v("status_code",f.target.value),value:O.status_code,children:Xf.map(f=>s.jsx("option",{value:f.value,children:f.label},f.value))})})]}),s.jsxs("div",{className:"field-grid",children:[s.jsx(H,{label:"State",children:s.jsx("input",{onChange:f=>v("campaign_state",f.target.value),type:"text",value:O.campaign_state})}),s.jsx(H,{label:"Subtype",children:s.jsx("input",{onChange:f=>v("campaign_subtype",f.target.value),type:"text",value:O.campaign_subtype})}),s.jsx(H,{label:"Segment by",children:s.jsx("select",{onChange:f=>v("segment_by",f.target.value),value:O.segment_by,children:Jf.map(f=>s.jsx("option",{value:f.value,children:f.label},f.value))})}),s.jsx(H,{label:"Locate by",children:s.jsx("input",{onChange:f=>v("locate_by",f.target.value),type:"text",value:O.locate_by})})]}),s.jsxs("div",{className:"field-grid",children:[s.jsx(H,{label:"Target ordering",children:s.jsx("input",{onChange:f=>v("target_ordering",f.target.value),type:"text",value:O.target_ordering})}),s.jsx(H,{label:"Target offices",children:s.jsx("input",{onChange:f=>v("target_offices",f.target.value),type:"text",value:O.target_offices})}),s.jsx(H,{label:"Include special",children:s.jsx("input",{onChange:f=>v("include_special",f.target.value),type:"text",value:O.include_special})}),s.jsx(H,{label:"Call maximum",children:s.jsx("input",{min:"0",onChange:f=>v("call_maximum",f.target.value),type:"number",value:O.call_maximum})})]}),s.jsx(H,{label:"Phone numbers",children:s.jsx("select",{className:"multi-select",multiple:!0,onChange:f=>{const I=Array.from(f.target.selectedOptions).map($=>Number($.value));v("phone_number_ids",I)},value:O.phone_number_ids.map(String),children:Te.map(f=>s.jsx("option",{value:f.id,children:f.number||`Phone #${f.id}`},f.id))})}),s.jsx(H,{label:"Search targets",children:s.jsx("input",{onChange:f=>mt(f.target.value),placeholder:"Search targets by name, key, or location",type:"text",value:J})}),s.jsx(H,{label:"Targets",children:s.jsx("select",{className:"multi-select",multiple:!0,onChange:f=>{const I=Array.from(f.target.selectedOptions).map($=>Number($.value));v("target_ids",I)},value:O.target_ids.map(String),children:ie.map(f=>s.jsx("option",{value:f.id,children:[f.title,f.name,f.location].filter(Boolean).join(" - ")},f.id))})}),s.jsxs("div",{className:"toggle-grid",children:[s.jsxs("label",{className:"toggle",children:[s.jsx("input",{checked:O.target_shuffle_chamber,onChange:f=>v("target_shuffle_chamber",f.target.checked),type:"checkbox"}),s.jsx("span",{children:"Shuffle within chamber"})]}),s.jsxs("label",{className:"toggle",children:[s.jsx("input",{checked:O.allow_call_in,onChange:f=>v("allow_call_in",f.target.checked),type:"checkbox"}),s.jsx("span",{children:"Allow call in"})]}),s.jsxs("label",{className:"toggle",children:[s.jsx("input",{checked:O.allow_intl_calls,onChange:f=>v("allow_intl_calls",f.target.checked),type:"checkbox"}),s.jsx("span",{children:"Allow international calls"})]}),s.jsxs("label",{className:"toggle",children:[s.jsx("input",{checked:O.prompt_schedule,onChange:f=>v("prompt_schedule",f.target.checked),type:"checkbox"}),s.jsx("span",{children:"Prompt schedule"})]})]}),s.jsxs("div",{className:"section-divider",children:[s.jsx("span",{className:"eyebrow",children:"Launch"}),s.jsx("h3",{children:"Embed settings"})]}),s.jsxs("div",{className:"field-grid",children:[s.jsx(H,{label:"Embed type",children:s.jsx("select",{onChange:f=>v("embed_type",f.target.value),value:O.embed_type,children:Zf.map(f=>s.jsx("option",{value:f.value,children:f.label},f.value))})}),s.jsx(H,{label:"Script display",children:s.jsx("select",{onChange:f=>v("embed_script_display",f.target.value),value:O.embed_script_display,children:qf.map(f=>s.jsx("option",{value:f.value,children:f.label},f.value))})})]}),s.jsx(H,{label:"Embed script",children:s.jsx("textarea",{onChange:f=>v("embed_script",f.target.value),rows:"4",value:O.embed_script})}),s.jsxs("div",{className:"field-grid",children:[s.jsx(H,{label:"Form selector",children:s.jsx("input",{onChange:f=>v("embed_form_sel",f.target.value),type:"text",value:O.embed_form_sel})}),s.jsx(H,{label:"Phone selector",children:s.jsx("input",{onChange:f=>v("embed_phone_sel",f.target.value),type:"text",value:O.embed_phone_sel})}),s.jsx(H,{label:"Location selector",children:s.jsx("input",{onChange:f=>v("embed_location_sel",f.target.value),type:"text",value:O.embed_location_sel})}),s.jsx(H,{label:"Phone display",children:s.jsx("input",{onChange:f=>v("embed_phone_display",f.target.value),type:"text",value:O.embed_phone_display})})]}),s.jsxs("div",{className:"field-grid",children:[s.jsx(H,{label:"Custom CSS URL",children:s.jsx("input",{onChange:f=>v("embed_custom_css",f.target.value),type:"text",value:O.embed_custom_css})}),s.jsx(H,{label:"Redirect URL",children:s.jsx("input",{onChange:f=>v("embed_redirect",f.target.value),type:"text",value:O.embed_redirect})})]}),s.jsx(H,{label:"Custom JS success callback",children:s.jsx("textarea",{onChange:f=>v("embed_custom_js",f.target.value),rows:"3",value:O.embed_custom_js})}),s.jsx(H,{label:"Custom JS onload",children:s.jsx("textarea",{onChange:f=>v("embed_custom_onload",f.target.value),rows:"3",value:O.embed_custom_onload})}),s.jsxs("div",{className:"section-divider",children:[s.jsx("span",{className:"eyebrow",children:"CRM"}),s.jsx("h3",{children:"Sync settings"})]}),s.jsx("div",{className:"toggle-grid",children:s.jsxs("label",{className:"toggle",children:[s.jsx("input",{checked:O.crm_sync,onChange:f=>v("crm_sync",f.target.checked),type:"checkbox"}),s.jsx("span",{children:"Enable CRM sync"})]})}),s.jsxs("div",{className:"field-grid",children:[s.jsx(H,{label:"Sync schedule",children:s.jsx("select",{onChange:f=>v("sync_schedule",f.target.value),value:O.sync_schedule,children:bf.map(f=>s.jsx("option",{value:f.value,children:f.label},f.value))})}),s.jsx(H,{label:"CRM campaign ID",children:s.jsx("input",{onChange:f=>v("crm_id",f.target.value),type:"text",value:O.crm_id})}),s.jsx(H,{label:"CRM key",children:s.jsx("input",{onChange:f=>v("crm_key",f.target.value),type:"text",value:O.crm_key})})]}),s.jsx("div",{className:"form-actions",children:s.jsx("button",{className:"button button-accent",type:"submit",children:ne?"Create campaign":"Save campaign"})})]})]})]}),!ne&&Y?s.jsx(nd,{audioForm:ze,audioState:nt,audioVersions:ht,onAudioAction:hn,onAudioFieldChange:B,onAudioUpload:Ke}):null,!ne&&Y?s.jsxs("section",{className:"panel launch-panel",children:[s.jsxs("div",{className:"panel-header",children:[s.jsxs("div",{children:[s.jsx("span",{className:"eyebrow",children:"Launch"}),s.jsx("h2",{children:"Test and go live"})]}),C.message?s.jsx("p",{className:`status-message status-${C.status}`,children:C.message}):s.jsx("p",{children:"Place a test call from the new Django/Twilio flow, then launch the campaign."})]}),s.jsxs("form",{className:"editor-form",onSubmit:vn,children:[s.jsxs("div",{className:"field-grid",children:[s.jsx(H,{label:"Test phone",children:s.jsx("input",{onChange:f=>K("userPhone",f.target.value),placeholder:"+12025550123",type:"text",value:we.userPhone})}),s.jsx(H,{label:"Country",children:s.jsx("input",{maxLength:2,onChange:f=>K("userCountry",f.target.value.toUpperCase()),type:"text",value:we.userCountry})})]}),s.jsx(H,{label:"Location",children:s.jsx("input",{onChange:f=>K("userLocation",f.target.value),placeholder:"ZIP, postal code, or district context",type:"text",value:we.userLocation})}),s.jsx("div",{className:"toggle-grid",children:s.jsxs("label",{className:"toggle",children:[s.jsx("input",{checked:we.record,onChange:f=>K("record",f.target.checked),type:"checkbox"}),s.jsx("span",{children:"Record test call"})]})}),s.jsxs("div",{className:"form-actions",children:[s.jsx("button",{className:"button",type:"submit",children:"Place test call"}),s.jsx("button",{className:"button button-accent",onClick:Lr,type:"button",children:"Launch campaign"})]})]})]}):null]}):s.jsx(ed,{credentials:g,loginState:A,onChange:V,onSubmit:Hn}):s.jsx("main",{className:"login-page",children:s.jsx("section",{className:"panel login-panel",children:s.jsx("p",{children:"Checking session…"})})})}Yf.createRoot(document.getElementById("root")).render(s.jsx(Vf.StrictMode,{children:s.jsx(rd,{})})); diff --git a/django_app/templates/account/_form_fields.html b/django_app/templates/account/_form_fields.html new file mode 100644 index 00000000..a1414057 --- /dev/null +++ b/django_app/templates/account/_form_fields.html @@ -0,0 +1,15 @@ +{% for field in form %} +
+ {{ field.label_tag }} + {{ field }} + {% if field.help_text %} +

{{ field.help_text }}

+ {% endif %} + {% for error in field.errors %} +

{{ error }}

+ {% endfor %} +
+{% endfor %} +{% for error in form.non_field_errors %} +

{{ error }}

+{% endfor %} diff --git a/django_app/templates/account/base.html b/django_app/templates/account/base.html new file mode 100644 index 00000000..cd40fdb8 --- /dev/null +++ b/django_app/templates/account/base.html @@ -0,0 +1,177 @@ + + + + + + {% block title %}{{ sitename }}{% endblock %} + + + +
+
+
+
Django account workflows
+

{{ sitename }}

+
+ +
+ + {% if messages %} +
+ {% for message in messages %} +
{{ message }}
+ {% endfor %} +
+ {% endif %} + + {% block content %}{% endblock %} +
+ + diff --git a/django_app/templates/account/change_password.html b/django_app/templates/account/change_password.html new file mode 100644 index 00000000..01fe725b --- /dev/null +++ b/django_app/templates/account/change_password.html @@ -0,0 +1,13 @@ +{% extends "account/base.html" %} +{% block title %}Change Password | {{ sitename }}{% endblock %} +{% block content %} +
+
Account
+

Change Password{% if legacy_user_record %} for {{ legacy_user_record.name }}{% endif %}

+
+ {% csrf_token %} + {% include "account/_form_fields.html" %} + +
+
+{% endblock %} diff --git a/django_app/templates/account/create_account.html b/django_app/templates/account/create_account.html new file mode 100644 index 00000000..834c4cca --- /dev/null +++ b/django_app/templates/account/create_account.html @@ -0,0 +1,14 @@ +{% extends "account/base.html" %} +{% block title %}Create Account | {{ sitename }}{% endblock %} +{% block content %} +
+
Invitation
+

Create Account

+

Finish your invited account setup to access the new Django admin.

+
+ {% csrf_token %} + {% include "account/_form_fields.html" %} + +
+
+{% endblock %} diff --git a/django_app/templates/account/email/invite_user.txt b/django_app/templates/account/email/invite_user.txt new file mode 100644 index 00000000..e6402623 --- /dev/null +++ b/django_app/templates/account/email/invite_user.txt @@ -0,0 +1,6 @@ +{% autoescape off %} +{{ sitename }} has created an account for you to administer campaigns. + +Click this link to log in and create your user profile. +{{ url }} +{% endautoescape %} diff --git a/django_app/templates/account/email/reset_password.txt b/django_app/templates/account/email/reset_password.txt new file mode 100644 index 00000000..182af47c --- /dev/null +++ b/django_app/templates/account/email/reset_password.txt @@ -0,0 +1,8 @@ +{% autoescape off %} +{{ sitename }} received a request to reset the password for your account {{ username }}. + +If you want to reset your password, click on the link below: +{{ url }} + +If you don't want to reset your password, please ignore this message. Your password will not be reset. +{% endautoescape %} diff --git a/django_app/templates/account/forbidden.html b/django_app/templates/account/forbidden.html new file mode 100644 index 00000000..5302d4cd --- /dev/null +++ b/django_app/templates/account/forbidden.html @@ -0,0 +1,9 @@ +{% extends "account/base.html" %} +{% block title %}Forbidden | {{ sitename }}{% endblock %} +{% block content %} +
+
Access
+

Forbidden

+

You don’t have permission to access this account workflow.

+
+{% endblock %} diff --git a/django_app/templates/account/invalid_invitation.html b/django_app/templates/account/invalid_invitation.html new file mode 100644 index 00000000..877f9d7e --- /dev/null +++ b/django_app/templates/account/invalid_invitation.html @@ -0,0 +1,9 @@ +{% extends "account/base.html" %} +{% block title %}Invalid Invitation | {{ sitename }}{% endblock %} +{% block content %} +
+
Invitation
+

Error: Invalid Invitation Key

+

Please check your email, or contact your administrator.

+
+{% endblock %} diff --git a/django_app/templates/account/invite.html b/django_app/templates/account/invite.html new file mode 100644 index 00000000..98fce96a --- /dev/null +++ b/django_app/templates/account/invite.html @@ -0,0 +1,14 @@ +{% extends "account/base.html" %} +{% block title %}Invite User | {{ sitename }}{% endblock %} +{% block content %} +
+
Admin
+

Invite User

+

This sends a create-account link through Django’s mail backend.

+
+ {% csrf_token %} + {% include "account/_form_fields.html" %} + +
+
+{% endblock %} diff --git a/django_app/templates/account/list.html b/django_app/templates/account/list.html new file mode 100644 index 00000000..2c41ad0e --- /dev/null +++ b/django_app/templates/account/list.html @@ -0,0 +1,49 @@ +{% extends "account/base.html" %} +{% block title %}Manage Users | {{ sitename }}{% endblock %} +{% block content %} +
+
+
+
Admin
+

Manage Users

+
+ Invite + +
+ + + + + + + + + + + + + + {% for user in users %} + + + + + + + + + + {% empty %} + + {% endfor %} + +
UsernameEmailPhoneRoleLast LoginStatusEdit
{{ user.name }}{{ user.email }}{{ user.phone|default:"" }}{{ user.role }}{% if user.last_accessed %}{{ user.last_accessed|date:"Y-m-d" }}{% else %}Never{% endif %}{{ user.status }} + Profile + / + Role + {% if legacy_user and legacy_user.is_admin %} + / + Remove + {% endif %} +
No users found.
+
+{% endblock %} diff --git a/django_app/templates/account/login.html b/django_app/templates/account/login.html new file mode 100644 index 00000000..d6fcf527 --- /dev/null +++ b/django_app/templates/account/login.html @@ -0,0 +1,17 @@ +{% extends "account/base.html" %} +{% block title %}Sign in | {{ sitename }}{% endblock %} +{% block content %} +
+
Account
+

Sign in

+

Use your existing Call Power username or email and password.

+
+ {% csrf_token %} + {% include "account/_form_fields.html" %} +
+ + Forgot your password? +
+
+
+{% endblock %} diff --git a/django_app/templates/account/logout.html b/django_app/templates/account/logout.html new file mode 100644 index 00000000..b338aa23 --- /dev/null +++ b/django_app/templates/account/logout.html @@ -0,0 +1,13 @@ +{% extends "account/base.html" %} +{% block title %}Log out | {{ sitename }}{% endblock %} +{% block content %} +
+
Session
+

Log out

+

This ends your Django session for the migrated admin and account pages.

+
+ {% csrf_token %} + +
+
+{% endblock %} diff --git a/django_app/templates/account/profile.html b/django_app/templates/account/profile.html new file mode 100644 index 00000000..c78d20a8 --- /dev/null +++ b/django_app/templates/account/profile.html @@ -0,0 +1,18 @@ +{% extends "account/base.html" %} +{% block title %}Profile | {{ sitename }}{% endblock %} +{% block content %} +
+
Profile
+

Update Profile{% if target_user %} for {{ target_user.name }}{% endif %}

+
+ {% csrf_token %} + {% include "account/_form_fields.html" %} +
+ + {% if legacy_user and legacy_user.id == target_user.id %} + Change password + {% endif %} +
+
+
+{% endblock %} diff --git a/django_app/templates/account/reauth.html b/django_app/templates/account/reauth.html new file mode 100644 index 00000000..bd2cc003 --- /dev/null +++ b/django_app/templates/account/reauth.html @@ -0,0 +1,14 @@ +{% extends "account/base.html" %} +{% block title %}Reauthenticate | {{ sitename }}{% endblock %} +{% block content %} +
+
Security
+

Reauthenticate

+

Confirm your password before changing sensitive account details.

+
+ {% csrf_token %} + {% include "account/_form_fields.html" %} + +
+
+{% endblock %} diff --git a/django_app/templates/account/remove.html b/django_app/templates/account/remove.html new file mode 100644 index 00000000..521ae7a8 --- /dev/null +++ b/django_app/templates/account/remove.html @@ -0,0 +1,14 @@ +{% extends "account/base.html" %} +{% block title %}Remove User | {{ sitename }}{% endblock %} +{% block content %} +
+
Admin
+

Remove User{% if target_user %} - {{ target_user.name }}{% endif %}

+

Type the username exactly to confirm permanent removal.

+
+ {% csrf_token %} + {% include "account/_form_fields.html" %} + +
+
+{% endblock %} diff --git a/django_app/templates/account/reset_password.html b/django_app/templates/account/reset_password.html new file mode 100644 index 00000000..9cdb71ee --- /dev/null +++ b/django_app/templates/account/reset_password.html @@ -0,0 +1,14 @@ +{% extends "account/base.html" %} +{% block title %}Reset Password | {{ sitename }}{% endblock %} +{% block content %} +
+
Recovery
+

Reset Password

+

We’ll email a reset link if the address matches an existing account.

+
+ {% csrf_token %} + {% include "account/_form_fields.html" %} + +
+
+{% endblock %} diff --git a/django_app/templates/account/role.html b/django_app/templates/account/role.html new file mode 100644 index 00000000..2bc59e96 --- /dev/null +++ b/django_app/templates/account/role.html @@ -0,0 +1,13 @@ +{% extends "account/base.html" %} +{% block title %}User Role | {{ sitename }}{% endblock %} +{% block content %} +
+
Admin
+

User Role{% if target_user %} for {{ target_user.name }}{% endif %}

+
+ {% csrf_token %} + {% include "account/_form_fields.html" %} + +
+
+{% endblock %} diff --git a/django_app/templates/admin_app.html b/django_app/templates/admin_app.html new file mode 100644 index 00000000..f8950c7c --- /dev/null +++ b/django_app/templates/admin_app.html @@ -0,0 +1,20 @@ + + + + + + Call Power Admin + {% if debug %} + + + {% else %} + + {% endif %} + + +
+ {% if not debug %} + + {% endif %} + + diff --git a/django_app/templates/public/CallPowerForm.js b/django_app/templates/public/CallPowerForm.js new file mode 100644 index 00000000..8d2e34de --- /dev/null +++ b/django_app/templates/public/CallPowerForm.js @@ -0,0 +1,206 @@ +var CallPowerForm = function(formSelector, $) { + this.$ = $; + this.form = this.$(formSelector); + this.locationField = this.$("{{ campaign.embed.location_sel|default:'#location_id' }}"); + this.phoneField = this.$("{{ campaign.embed.phone_sel|default:'#phone_id' }}"); + this.locateBy = "{{ campaign.locate_by|default:'' }}"; + this.scriptDisplay = "overlay"; + + for (var option in window.CallPowerOptions || {}) { + if (!Object.prototype.hasOwnProperty.call(window.CallPowerOptions, option)) { + continue; + } + var setting = window.CallPowerOptions[option]; + var selectorFields = ["form", "locationField", "phoneField"]; + if ($.inArray(option, selectorFields) !== -1 && typeof setting === "string") { + this[option] = this.$(setting); + } else { + this[option] = setting; + } + } + + this.form.on("submit.CallPower", this.$.proxy(this.makeCall, this)); + if (this.customCSS !== undefined) { + this.$("head").append(''); + } +}; + +CallPowerForm.prototype = function() { + var createCallURL = "{{ base_url }}{% url 'call-create' %}"; + var campaignId = "{{ campaign.id }}"; + + var getCountry = function() { + return "{{ campaign.country_code|default:'US' }}"; + }; + + var cleanUSZipcode = function(val) { + if (val.length === 0) return undefined; + return /(\d{5}([\-]\d{4})?)/.test(val) ? val : false; + }; + + var cleanCAPostal = function(val) { + if (val.length === 0) return undefined; + var valNospace = val.replace(/\W+/g, ""); + return /([ABCEGHJKLMNPRSTVXY]\d)([ABCEGHJKLMNPRSTVWXYZ]\d){2}/i.test(valNospace) ? valNospace : false; + }; + + var getLocation = function() { + var countryCode = this.country(); + var locationVal = ""; + + if (this.locationField.length === 1) { + locationVal = this.locationField.val(); + } else if (this.locationField.length > 1) { + this.locationField.each(function() { + locationVal += " " + $(this).val(); + }); + locationVal = locationVal.trim(); + } + + if (this.locateBy === "postal") { + if (countryCode === "US") return cleanUSZipcode(locationVal); + if (countryCode === "CA") return cleanCAPostal(locationVal); + } + return locationVal; + }; + + var getPhone = function() { + if (this.phoneField.length === 0) return undefined; + return this.phoneField.val() + .replace(/\s/g, "") + .replace(/\(/g, "") + .replace(/\)/g, "") + .replace("+", "") + .replace(/\-/g, ""); + }; + + var onSuccess = function(response) { + if (response.campaign === "archived") return this.onError(this.form, "This campaign is no longer active."); + if (response.campaign !== "live") return this.onError(this.form, "This campaign is not live."); + if (response.call !== "queued") return this.onError(this.form, "Could not start call."); + + if (this.phoneDisplay) { + $(this.phoneDisplay).html(response.fromNumber); + } + + if (this.scriptDisplay === "overlay") { + var closeButton = ''; + var closeText = this.overlayCloseText ? '' + this.overlayCloseText + "" : ""; + var scriptOverlay = this.$( + '
' + closeButton + (response.script || "") + closeText + "
" + ); + this.$("body").append(scriptOverlay); + if (scriptOverlay.overlay) { + scriptOverlay.overlay(); + } + scriptOverlay.css("visibility", "visible").addClass("shown"); + } + + if (this.scriptDisplay === "replace") { + var scriptDiv = this.$('
'); + scriptDiv.addClass(this.form.attr("class")); + scriptDiv.attr("id", "callpower_script_response"); + scriptDiv.html(response.script || "

Calling now.

"); + scriptDiv.insertAfter(this.form); + this.form.slideUp(); + scriptDiv.slideDown(); + } + + if (this.scriptDisplay === "redirect") { + this.redirectAfter = response.redirect; + } + + if (this.scriptDisplay === "alert") { + var message = this.$(response.script || ""); + alert(message.text() || "Calling now."); + } + + if (typeof this.customJS !== "undefined") { + if (typeof this.customJS === "string") { + eval(this.customJS); + } else if (typeof this.customJS === "function") { + this.customJS(); + } + } + + return true; + }; + + var onError = function(element, message) { + if (element !== undefined && element.addClass) { + element.addClass("has-error"); + } + console.error("CallPower error: " + message); + return false; + }; + + var makeCall = function(event) { + if (event !== undefined) { + event.preventDefault(); + event.stopImmediatePropagation(); + } + + if (this.locationField.length && !this.location()) { + return this.onError(this.locationField, "Invalid location"); + } + if (this.phoneField.length && !this.phone()) { + return this.onError(this.phoneField, "Invalid phone number"); + } + + this.$.ajax(createCallURL, { + method: "GET", + data: { + campaignId: campaignId, + userLocation: this.location(), + userPhone: this.phone(), + userCountry: this.country() + }, + statusCode: { + 429: function() { + alert("Sorry, you have made too many requests in the last hour. Please try again later."); + } + } + }) + .done(this.$.proxy(this.onSuccess, this)) + .then(this.$.proxy(function() { + this.form.off("submit.CallPower"); + if (this.scriptDisplay === "overlay") { + var scriptOverlay = this.$(".overlay"); + scriptOverlay.on("hide", this.$.proxy(this.formSubmit, this)); + scriptOverlay.on("click", this.$.proxy(function(e) { + var target = $(e.target); + if (target.hasClass(scriptOverlay.attr("class")) || target.hasClass("close") || target.hasClass("closeText")) { + return scriptOverlay.trigger("hide"); + } + }, this)); + } else if (this.scriptDisplay === "redirect" && this.redirectAfter) { + window.location.replace(this.redirectAfter); + } else if (this.scriptDisplay !== "replace") { + this.formSubmit(); + } + }, this)) + .fail(this.$.proxy(this.onError, this, this.form, "Sorry, there was an error making the call")); + + return false; + }; + + var formSubmit = function() { + window.setTimeout(this.$.proxy(function() { + this.form.trigger("submit"); + }, this), this.submitDelay || 0); + }; + + var publicApi = { + getCountry: getCountry, + getLocation: getLocation, + getPhone: getPhone, + onError: onError, + onSuccess: onSuccess, + makeCall: makeCall, + formSubmit: formSubmit + }; + publicApi.country = publicApi.getCountry; + publicApi.location = publicApi.getLocation; + publicApi.phone = publicApi.getPhone; + return publicApi; +}(); diff --git a/django_app/templates/public/campaign_page.html b/django_app/templates/public/campaign_page.html new file mode 100644 index 00000000..cd8cab4c --- /dev/null +++ b/django_app/templates/public/campaign_page.html @@ -0,0 +1,109 @@ +{% load static %} + + + + + + {{ campaign.name }} | Call Power + + + + +
+
+

Public Campaign

+

{{ campaign.name }}

+

Enter your phone number and we’ll connect you to the right call flow for this campaign.

+ +
+ + + {% if campaign.segment_by == 'location' %} + + {% endif %} + + +
+ +
+
+
+ + + + + diff --git a/django_app/templates/public/embed.js b/django_app/templates/public/embed.js new file mode 100644 index 00000000..2583e91e --- /dev/null +++ b/django_app/templates/public/embed.js @@ -0,0 +1,68 @@ +{% load static %} +{% include "public/CallPowerForm.js" with campaign=campaign base_url=base_url %} + +var main = function($) { + var callPowerForm; + if (window.CallPowerOptions && window.CallPowerOptions.form) { + callPowerForm = new CallPowerForm(window.CallPowerOptions.form, $); + } else { + callPowerForm = new CallPowerForm("form", $); + } + + if (window.CallPowerOptions && window.CallPowerOptions.scriptDisplay === "overlay" && !$.overlay) { + $.getScript("{{ base_url }}{% static 'embed/overlay.js' %}"); + $("head").append(''); + } + + if (window.CallPowerOptions && typeof window.CallPowerOptions.customOnload !== "undefined") { + if (typeof window.CallPowerOptions.customOnload === "function") { + window.CallPowerOptions.customOnload(); + } + } +}; + +function versionCmp(a, b) { + var pa = a.split("."); + var pb = b.split("."); + for (var i = 0; i < 3; i++) { + var na = Number(pa[i]); + var nb = Number(pb[i]); + if (na > nb) return 1; + if (nb > na) return -1; + if (!isNaN(na) && isNaN(nb)) return 1; + if (isNaN(na) && !isNaN(nb)) return -1; + } + return 0; +} + +function getScript(url, success, cors) { + var script = document.createElement("script"); + script.src = url; + if (cors) { + script.crossOrigin = cors; + } + var head = document.getElementsByTagName("head")[0]; + var done = false; + script.onload = script.onreadystatechange = function() { + if (!done && (!this.readyState || this.readyState === "loaded" || this.readyState === "complete")) { + done = true; + success(); + script.onload = script.onreadystatechange = null; + head.removeChild(script); + } + }; + head.appendChild(script); +} + +if (typeof window.jQuery === "undefined") { + getScript("//cdnjs.cloudflare.com/ajax/libs/jquery/1.12.4/jquery.js", function() { + return main(jQuery); + }); +} else if (versionCmp(window.jQuery.fn.jquery, "1.7.0") < 0) { + getScript("//cdnjs.cloudflare.com/ajax/libs/jquery/1.12.4/jquery.min.js", function() { + jQuery.noConflict(); + return main(jQuery); + }); +} else { + jQuery(document).ready(main); +} diff --git a/django_app/templates/public/embed_code.html b/django_app/templates/public/embed_code.html new file mode 100644 index 00000000..9b85344e --- /dev/null +++ b/django_app/templates/public/embed_code.html @@ -0,0 +1,21 @@ +{% load static %} +{% if campaign.embed.type == 'iframe' %} + + + + +{% elif campaign.embed.type == 'custom' %} + + +{% endif %} diff --git a/django_app/templates/public/embed_iframe.html b/django_app/templates/public/embed_iframe.html new file mode 100644 index 00000000..ea86d3c6 --- /dev/null +++ b/django_app/templates/public/embed_iframe.html @@ -0,0 +1,71 @@ +{% load static %} + + + + + + + + + +
+
+
+ +
+ + +
+
+ + {% if campaign.segment_by == 'location' %} +
+ +
+ + +
+
+ {% endif %} + +
+
+ +
+
+
+
+ + + + + + + diff --git a/django_app/templates/public/index.html b/django_app/templates/public/index.html new file mode 100644 index 00000000..8ef2e433 --- /dev/null +++ b/django_app/templates/public/index.html @@ -0,0 +1,40 @@ + + + + + + Call Power + + + +
+

Connecting people to power through their phones

+

A project of OpenSourceActivism.tech and {{ installed_org }}.

+
+ + diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 00000000..135e708e --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,12 @@ + + + + + + Call Power Admin + + +
+ + + diff --git a/frontend/package-lock.json b/frontend/package-lock.json new file mode 100644 index 00000000..bf321f92 --- /dev/null +++ b/frontend/package-lock.json @@ -0,0 +1,1794 @@ +{ + "name": "call-power-admin", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "call-power-admin", + "version": "0.1.0", + "dependencies": { + "react": "^18.3.1", + "react-dom": "^18.3.1" + }, + "devDependencies": { + "@vitejs/plugin-react": "^4.3.4", + "vite": "^6.0.5" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", + "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.28.5", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz", + "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", + "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-module-transforms": "^7.28.6", + "@babel/helpers": "^7.28.6", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/traverse": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/generator": { + "version": "7.29.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", + "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz", + "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.28.6", + "@babel/helper-validator-option": "^7.27.1", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz", + "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz", + "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.28.6", + "@babel/helper-validator-identifier": "^7.28.5", + "@babel/traverse": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz", + "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", + "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz", + "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz", + "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.0" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz", + "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-source": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz", + "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz", + "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.28.6", + "@babel/parser": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", + "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz", + "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz", + "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz", + "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz", + "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz", + "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz", + "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz", + "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz", + "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz", + "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz", + "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz", + "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz", + "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz", + "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz", + "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz", + "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz", + "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz", + "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz", + "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz", + "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz", + "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz", + "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz", + "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz", + "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz", + "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz", + "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz", + "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.0-beta.27", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz", + "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.1.tgz", + "integrity": "sha512-d6FinEBLdIiK+1uACUttJKfgZREXrF0Qc2SmLII7W2AD8FfiZ9Wjd+rD/iRuf5s5dWrr1GgwXCvPqOuDquOowA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.1.tgz", + "integrity": "sha512-YjG/EwIDvvYI1YvYbHvDz/BYHtkY4ygUIXHnTdLhG+hKIQFBiosfWiACWortsKPKU/+dUwQQCKQM3qrDe8c9BA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.1.tgz", + "integrity": "sha512-mjCpF7GmkRtSJwon+Rq1N8+pI+8l7w5g9Z3vWj4T7abguC4Czwi3Yu/pFaLvA3TTeMVjnu3ctigusqWUfjZzvw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.1.tgz", + "integrity": "sha512-haZ7hJ1JT4e9hqkoT9R/19XW2QKqjfJVv+i5AGg57S+nLk9lQnJ1F/eZloRO3o9Scy9CM3wQ9l+dkXtcBgN5Ew==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.1.tgz", + "integrity": "sha512-czw90wpQq3ZsAVBlinZjAYTKduOjTywlG7fEeWKUA7oCmpA8xdTkxZZlwNJKWqILlq0wehoZcJYfBvOyhPTQ6w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.1.tgz", + "integrity": "sha512-KVB2rqsxTHuBtfOeySEyzEOB7ltlB/ux38iu2rBQzkjbwRVlkhAGIEDiiYnO2kFOkJp+Z7pUXKyrRRFuFUKt+g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.1.tgz", + "integrity": "sha512-L+34Qqil+v5uC0zEubW7uByo78WOCIrBvci69E7sFASRl0X7b/MB6Cqd1lky/CtcSVTydWa2WZwFuWexjS5o6g==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.1.tgz", + "integrity": "sha512-n83O8rt4v34hgFzlkb1ycniJh7IR5RCIqt6mz1VRJD6pmhRi0CXdmfnLu9dIUS6buzh60IvACM842Ffb3xd6Gg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.1.tgz", + "integrity": "sha512-Nql7sTeAzhTAja3QXeAI48+/+GjBJ+QmAH13snn0AJSNL50JsDqotyudHyMbO2RbJkskbMbFJfIJKWA6R1LCJQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.1.tgz", + "integrity": "sha512-+pUymDhd0ys9GcKZPPWlFiZ67sTWV5UU6zOJat02M1+PiuSGDziyRuI/pPue3hoUwm2uGfxdL+trT6Z9rxnlMA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.1.tgz", + "integrity": "sha512-VSvgvQeIcsEvY4bKDHEDWcpW4Yw7BtlKG1GUT4FzBUlEKQK0rWHYBqQt6Fm2taXS+1bXvJT6kICu5ZwqKCnvlQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.1.tgz", + "integrity": "sha512-4LqhUomJqwe641gsPp6xLfhqWMbQV04KtPp7/dIp0nzPxAkNY1AbwL5W0MQpcalLYk07vaW9Kp1PBhdpZYYcEw==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.1.tgz", + "integrity": "sha512-tLQQ9aPvkBxOc/EUT6j3pyeMD6Hb8QF2BTBnCQWP/uu1lhc9AIrIjKnLYMEroIz/JvtGYgI9dF3AxHZNaEH0rw==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.1.tgz", + "integrity": "sha512-RMxFhJwc9fSXP6PqmAz4cbv3kAyvD1etJFjTx4ONqFP9DkTkXsAMU4v3Vyc5BgzC+anz7nS/9tp4obsKfqkDHg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.1.tgz", + "integrity": "sha512-QKgFl+Yc1eEk6MmOBfRHYF6lTxiiiV3/z/BRrbSiW2I7AFTXoBFvdMEyglohPj//2mZS4hDOqeB0H1ACh3sBbg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.1.tgz", + "integrity": "sha512-RAjXjP/8c6ZtzatZcA1RaQr6O1TRhzC+adn8YZDnChliZHviqIjmvFwHcxi4JKPSDAt6Uhf/7vqcBzQJy0PDJg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.1.tgz", + "integrity": "sha512-wcuocpaOlaL1COBYiA89O6yfjlp3RwKDeTIA0hM7OpmhR1Bjo9j31G1uQVpDlTvwxGn2nQs65fBFL5UFd76FcQ==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.1.tgz", + "integrity": "sha512-77PpsFQUCOiZR9+LQEFg9GClyfkNXj1MP6wRnzYs0EeWbPcHs02AXu4xuUbM1zhwn3wqaizle3AEYg5aeoohhg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.1.tgz", + "integrity": "sha512-5cIATbk5vynAjqqmyBjlciMJl1+R/CwX9oLk/EyiFXDWd95KpHdrOJT//rnUl4cUcskrd0jCCw3wpZnhIHdD9w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.1.tgz", + "integrity": "sha512-cl0w09WsCi17mcmWqqglez9Gk8isgeWvoUZ3WiJFYSR3zjBQc2J5/ihSjpl+VLjPqjQ/1hJRcqBfLjssREQILw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.1.tgz", + "integrity": "sha512-4Cv23ZrONRbNtbZa37mLSueXUCtN7MXccChtKpUnQNgF010rjrjfHx3QxkS2PI7LqGT5xXyYs1a7LbzAwT0iCA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.1.tgz", + "integrity": "sha512-i1okWYkA4FJICtr7KpYzFpRTHgy5jdDbZiWfvny21iIKky5YExiDXP+zbXzm3dUcFpkEeYNHgQ5fuG236JPq0g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.1.tgz", + "integrity": "sha512-u09m3CuwLzShA0EYKMNiFgcjjzwqtUMLmuCJLeZWjjOYA3IT2Di09KaxGBTP9xVztWyIWjVdsB2E9goMjZvTQg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.1.tgz", + "integrity": "sha512-k+600V9Zl1CM7eZxJgMyTUzmrmhB/0XZnF4pRypKAlAgxmedUA+1v9R+XOFv56W4SlHEzfeMtzujLJD22Uz5zg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.1.tgz", + "integrity": "sha512-lWMnixq/QzxyhTV6NjQJ4SFo1J6PvOX8vUx5Wb4bBPsEb+8xZ89Bz6kOXpfXj9ak9AHTQVQzlgzBEc1SyM27xQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.27.0", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz", + "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz", + "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.2" + } + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@vitejs/plugin-react": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz", + "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.28.0", + "@babel/plugin-transform-react-jsx-self": "^7.27.1", + "@babel/plugin-transform-react-jsx-source": "^7.27.1", + "@rolldown/pluginutils": "1.0.0-beta.27", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.17.0" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/baseline-browser-mapping": { + "version": "2.10.19", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.19.tgz", + "integrity": "sha512-qCkNLi2sfBOn8XhZQ0FXsT1Ki/Yo5P90hrkRamVFRS7/KV9hpfA4HkoWNU152+8w0zPjnxo5psx5NL3PSGgv5g==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/browserslist": { + "version": "4.28.2", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz", + "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.10.12", + "caniuse-lite": "^1.0.30001782", + "electron-to-chromium": "^1.5.328", + "node-releases": "^2.0.36", + "update-browserslist-db": "^1.2.3" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001788", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001788.tgz", + "integrity": "sha512-6q8HFp+lOQtcf7wBK+uEenxymVWkGKkjFpCvw5W25cmMwEDU45p1xQFBQv8JDlMMry7eNxyBaR+qxgmTUZkIRQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/electron-to-chromium": { + "version": "1.5.340", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.340.tgz", + "integrity": "sha512-908qahOGocRMinT2nM3ajCEM99H4iPdv84eagPP3FfZy/1ZGeOy2CZYzjhms81ckOPCXPlW7LkY4XpxD8r1DrA==", + "dev": true, + "license": "ISC" + }, + "node_modules/esbuild": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz", + "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.25.12", + "@esbuild/android-arm": "0.25.12", + "@esbuild/android-arm64": "0.25.12", + "@esbuild/android-x64": "0.25.12", + "@esbuild/darwin-arm64": "0.25.12", + "@esbuild/darwin-x64": "0.25.12", + "@esbuild/freebsd-arm64": "0.25.12", + "@esbuild/freebsd-x64": "0.25.12", + "@esbuild/linux-arm": "0.25.12", + "@esbuild/linux-arm64": "0.25.12", + "@esbuild/linux-ia32": "0.25.12", + "@esbuild/linux-loong64": "0.25.12", + "@esbuild/linux-mips64el": "0.25.12", + "@esbuild/linux-ppc64": "0.25.12", + "@esbuild/linux-riscv64": "0.25.12", + "@esbuild/linux-s390x": "0.25.12", + "@esbuild/linux-x64": "0.25.12", + "@esbuild/netbsd-arm64": "0.25.12", + "@esbuild/netbsd-x64": "0.25.12", + "@esbuild/openbsd-arm64": "0.25.12", + "@esbuild/openbsd-x64": "0.25.12", + "@esbuild/openharmony-arm64": "0.25.12", + "@esbuild/sunos-x64": "0.25.12", + "@esbuild/win32-arm64": "0.25.12", + "@esbuild/win32-ia32": "0.25.12", + "@esbuild/win32-x64": "0.25.12" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "license": "MIT" + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/node-releases": { + "version": "2.0.37", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.37.tgz", + "integrity": "sha512-1h5gKZCF+pO/o3Iqt5Jp7wc9rH3eJJ0+nh/CIoiRwjRxde/hAHyLPXYN4V3CqKAbiZPSeJFSWHmJsbkicta0Eg==", + "dev": true, + "license": "MIT" + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz", + "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.10", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.10.tgz", + "integrity": "sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/react": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz", + "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz", + "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0", + "scheduler": "^0.23.2" + }, + "peerDependencies": { + "react": "^18.3.1" + } + }, + "node_modules/react-refresh": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz", + "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/rollup": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.1.tgz", + "integrity": "sha512-VmtB2rFU/GroZ4oL8+ZqXgSA38O6GR8KSIvWmEFv63pQ0G6KaBH9s07PO8XTXP4vI+3UJUEypOfjkGfmSBBR0w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.60.1", + "@rollup/rollup-android-arm64": "4.60.1", + "@rollup/rollup-darwin-arm64": "4.60.1", + "@rollup/rollup-darwin-x64": "4.60.1", + "@rollup/rollup-freebsd-arm64": "4.60.1", + "@rollup/rollup-freebsd-x64": "4.60.1", + "@rollup/rollup-linux-arm-gnueabihf": "4.60.1", + "@rollup/rollup-linux-arm-musleabihf": "4.60.1", + "@rollup/rollup-linux-arm64-gnu": "4.60.1", + "@rollup/rollup-linux-arm64-musl": "4.60.1", + "@rollup/rollup-linux-loong64-gnu": "4.60.1", + "@rollup/rollup-linux-loong64-musl": "4.60.1", + "@rollup/rollup-linux-ppc64-gnu": "4.60.1", + "@rollup/rollup-linux-ppc64-musl": "4.60.1", + "@rollup/rollup-linux-riscv64-gnu": "4.60.1", + "@rollup/rollup-linux-riscv64-musl": "4.60.1", + "@rollup/rollup-linux-s390x-gnu": "4.60.1", + "@rollup/rollup-linux-x64-gnu": "4.60.1", + "@rollup/rollup-linux-x64-musl": "4.60.1", + "@rollup/rollup-openbsd-x64": "4.60.1", + "@rollup/rollup-openharmony-arm64": "4.60.1", + "@rollup/rollup-win32-arm64-msvc": "4.60.1", + "@rollup/rollup-win32-ia32-msvc": "4.60.1", + "@rollup/rollup-win32-x64-gnu": "4.60.1", + "@rollup/rollup-win32-x64-msvc": "4.60.1", + "fsevents": "~2.3.2" + } + }, + "node_modules/scheduler": { + "version": "0.23.2", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz", + "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + } + }, + "node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.16", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz", + "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/vite": { + "version": "6.4.2", + "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.2.tgz", + "integrity": "sha512-2N/55r4JDJ4gdrCvGgINMy+HH3iRpNIz8K6SFwVsA+JbQScLiC+clmAxBgwiSPgcG9U15QmvqCGWzMbqda5zGQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.25.0", + "fdir": "^6.4.4", + "picomatch": "^4.0.2", + "postcss": "^8.5.3", + "rollup": "^4.34.9", + "tinyglobby": "^0.2.13" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "jiti": ">=1.21.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + } + } +} diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 00000000..aedb5649 --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,19 @@ +{ + "name": "call-power-admin", + "private": true, + "version": "0.1.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "vite build", + "preview": "vite preview" + }, + "dependencies": { + "react": "^18.3.1", + "react-dom": "^18.3.1" + }, + "devDependencies": { + "@vitejs/plugin-react": "^4.3.4", + "vite": "^6.0.5" + } +} diff --git a/frontend/vite.config.js b/frontend/vite.config.js new file mode 100644 index 00000000..ac84a86d --- /dev/null +++ b/frontend/vite.config.js @@ -0,0 +1,30 @@ +import { defineConfig } from "vite"; +import react from "@vitejs/plugin-react"; + +export default defineConfig({ + plugins: [react()], + server: { + host: "0.0.0.0", + port: 5173, + proxy: { + "/api": "http://localhost:8000", + "/auth": "http://localhost:8000", + "/user": "http://localhost:8000", + "/admin/user": "http://localhost:8000", + "/call": "http://localhost:8000", + "/political_data": "http://localhost:8000", + "/media": "http://localhost:8000", + }, + }, + build: { + outDir: "../django_app/static/admin", + emptyOutDir: true, + rollupOptions: { + output: { + entryFileNames: "index.js", + chunkFileNames: "chunks/[name].js", + assetFileNames: "assets/[name][extname]", + }, + }, + }, +}); diff --git a/manage.py b/manage.py new file mode 100644 index 00000000..fd933489 --- /dev/null +++ b/manage.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python3 +import os +import sys + + +def main(): + sys.path.insert(0, os.path.join(os.path.dirname(__file__), "django_app")) + os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings") + from django.core.management import execute_from_command_line + + execute_from_command_line(sys.argv) + + +if __name__ == "__main__": + main() diff --git a/requirements/common.txt b/requirements/common.txt index 1fffe76c..eff98fb7 100644 --- a/requirements/common.txt +++ b/requirements/common.txt @@ -1,4 +1,7 @@ Babel==2.9.1 +dj-database-url==2.2.0 +Django==5.1.4 +djangorestframework==3.15.2 Flask==1.1.1 Flask-Assets==0.12 Flask-Babel==0.12.2 diff --git a/requirements/development.txt b/requirements/development.txt index c1899694..68ed26b9 100644 --- a/requirements/development.txt +++ b/requirements/development.txt @@ -1,9 +1,5 @@ -r common.txt -Flask-DebugToolbar==0.10.1 -flask-shell-ipython==0.4.0 -Flask-Testing==0.4.2 -nose==1.3.0 -cssmin==0.2.0 +pyngrok==8.0.0 coverage==4.4 coveralls==1.1 pip-upgrade diff --git a/scripts/match_exports.py b/scripts/match_exports.py new file mode 100644 index 00000000..d8974f03 --- /dev/null +++ b/scripts/match_exports.py @@ -0,0 +1,60 @@ +import csv +import argparse +import collections + +MATCH_DISTRICTS = ['HI-1', 'ME-2', 'FL-7', 'NY-4', 'OR-5'] +ZIPCODES_LOOKUP = collections.defaultdict(list) + +EXPORT = [] + +def main(loadfile): + zipcodes = {} + # load list of us_districts + with open('us_districts.csv') as zipcodes_file: + zipcodes = csv.DictReader(zipcodes_file) + for z in zipcodes: + # make faster lookup dict of lists + ZIPCODES_LOOKUP[z['zcta']].append({'state': z['state_abbr'], 'cd': z['cd']}) + print(f'loaded {len(ZIPCODES_LOOKUP)} zips') + + # load campaign export csv + with open(loadfile) as csvfile: + calls = csv.reader(csvfile) + + # check each entry for district match by zipcode + for row in calls: + # print(row) + call_lookup = ZIPCODES_LOOKUP.get(row[1]) + if not call_lookup: + print(f'unable to match {row[1]}') + continue + for z in call_lookup: + for m in MATCH_DISTRICTS: + match_state, match_cd = m.split('-') + if z['state'] == match_state and z['cd'] == match_cd: + matched_row = { + 'phone': row[0], + 'zip': row[1], + 'state': z['state'], + 'cd': z['cd'] + } + EXPORT.append(matched_row) + + print(f'got {len(EXPORT)} matches') + + # only export matches + with open('matched_calls.csv', 'w') as outfile: + writer = csv.DictWriter(outfile, fieldnames=['phone','zip','state','cd']) + writer.writeheader() + for row in EXPORT: + writer.writerow(row) + print('done') + +if __name__=="__main__": + import argparse + + parser = argparse.ArgumentParser(description='Match CallPower campaign export to specific districts') + parser.add_argument('filename', help='CSV file to load') + args = parser.parse_args() + + main(args.filename) \ No newline at end of file diff --git a/tests/__init__.py b/tests/__init__.py index e69de29b..73ff1590 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -0,0 +1,9 @@ +import os +import sys + +import django + + +sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(__file__)), "django_app")) +os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings") +django.setup() diff --git a/tests/run.py b/tests/run.py index 0cfb12c1..a9cae04d 100644 --- a/tests/run.py +++ b/tests/run.py @@ -1,29 +1,15 @@ -import pytest -from dotenv import load_dotenv +import os +import unittest -from flask_testing import TestCase +import django -if __name__ == '__main__' and __package__ is None: - load_dotenv() - from os import sys, path - sys.path.append(path.dirname(path.dirname(path.abspath(__file__)))) -from call_server.app import create_app, db -from call_server.config import TestingConfig -from call_server.extensions import assets +os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings") +django.setup() -class BaseTestCase(TestCase): +RUN_SLOW_TESTS = os.environ.get("RUN_SLOW_TESTS") == "1" +slow_test = unittest.skipUnless(RUN_SLOW_TESTS, "slow test") - def create_app(self): - assets._named_bundles = {} - return create_app(TestingConfig) - def setUp(self): - db.create_all() - - def tearDown(self): - db.session.remove() - db.drop_all() - -if __name__ == '__main__': - pytest.main() +class BaseTestCase(unittest.TestCase): + pass diff --git a/tests/test_admin_blocklist.py b/tests/test_admin_blocklist.py index 1f667356..a0ddfcf1 100644 --- a/tests/test_admin_blocklist.py +++ b/tests/test_admin_blocklist.py @@ -1,11 +1,10 @@ import logging -from datetime import datetime, timedelta +from datetime import timedelta from .run import BaseTestCase +from django.utils import timezone -from call_server.utils import utc_now -from call_server.extensions import db -from call_server.admin.models import Blocklist +from callpower.apps.core.models import Blocklist class TestBlocklist(BaseTestCase): @@ -24,8 +23,7 @@ def setUpClass(cls): def setUp(self, **kwargs): super(TestBlocklist, self).setUp(**kwargs) - Blocklist.query.delete() - db.session.commit() + Blocklist.objects.all().delete() def test_no_blocks(self): self.assertEqual(Blocklist.active_blocks(), []) @@ -35,13 +33,13 @@ def test_no_blocks(self): def test_phone_block(self): b = Blocklist(phone_number=self.user_phone) - db.session.add(b) - db.session.commit() + b.save() self.assertEqual(len(Blocklist.active_blocks()), 1) is_blocked = Blocklist.user_blocked(self.user_phone, self.user_ip) self.assertTrue(is_blocked) + b.refresh_from_db() other_blocked = Blocklist.user_blocked(self.other_phone, self.other_ip) self.assertFalse(other_blocked) @@ -51,13 +49,13 @@ def test_phone_block(self): def test_phone_hash_block(self): b = Blocklist() b.phone_hash = '2ceab7622c3ea1de7e5b1db8c90ed3c161a4d097df6755d21df8a349fe63089c' - db.session.add(b) - db.session.commit() + b.save() self.assertEqual(len(Blocklist.active_blocks()), 1) is_blocked = Blocklist.user_blocked(self.user_phone, self.user_ip) self.assertTrue(is_blocked) + b.refresh_from_db() other_blocked = Blocklist.user_blocked(self.other_phone, self.other_ip) self.assertFalse(other_blocked) @@ -66,13 +64,13 @@ def test_phone_hash_block(self): def test_ip_block(self): b = Blocklist(ip_address=self.user_ip) - db.session.add(b) - db.session.commit() + b.save() self.assertEqual(len(Blocklist.active_blocks()), 1) is_blocked = Blocklist.user_blocked(self.user_phone, self.user_ip) self.assertTrue(is_blocked) + b.refresh_from_db() other_blocked = Blocklist.user_blocked(self.other_phone, self.other_ip) self.assertFalse(other_blocked) @@ -82,13 +80,13 @@ def test_ip_block(self): def test_phone_and_ip_block(self): b = Blocklist(phone_number=self.user_phone, ip_address=self.user_ip) - db.session.add(b) - db.session.commit() + b.save() self.assertEqual(len(Blocklist.active_blocks()), 1) is_blocked = Blocklist.user_blocked(self.user_phone, self.user_ip) self.assertTrue(is_blocked) + b.refresh_from_db() other_blocked = Blocklist.user_blocked(self.other_phone, self.other_ip) self.assertFalse(other_blocked) @@ -98,14 +96,15 @@ def test_phone_and_ip_block(self): def test_separate_phone_ip_blocks(self): b_phone = Blocklist(phone_number=self.user_phone) b_ip = Blocklist(ip_address=self.user_ip) - db.session.add(b_phone) - db.session.add(b_ip) - db.session.commit() + b_phone.save() + b_ip.save() self.assertEqual(len(Blocklist.active_blocks()), 2) is_blocked = Blocklist.user_blocked(self.user_phone, self.user_ip) self.assertTrue(is_blocked) + b_phone.refresh_from_db() + b_ip.refresh_from_db() other_blocked = Blocklist.user_blocked(self.other_phone, self.other_ip) self.assertFalse(other_blocked) @@ -119,19 +118,22 @@ def test_separate_phone_ip_blocks_just_one_matches(self): b_phone = Blocklist(phone_number=self.user_phone) b_ip = Blocklist(ip_address=some_other_ip) - db.session.add(b_phone) - db.session.add(b_ip) - db.session.commit() + b_phone.save() + b_ip.save() self.assertEqual(len(Blocklist.active_blocks()), 2) is_blocked = Blocklist.user_blocked(self.user_phone, self.user_ip) self.assertTrue(is_blocked) + b_phone.refresh_from_db() + b_ip.refresh_from_db() self.assertEqual(b_phone.hits, 1) self.assertEqual(b_ip.hits, 0) someone_else_blocked = Blocklist.user_blocked(some_other_phone, some_other_ip) self.assertTrue(someone_else_blocked) + b_phone.refresh_from_db() + b_ip.refresh_from_db() self.assertEqual(b_phone.hits, 1) self.assertEqual(b_ip.hits, 1) @@ -142,24 +144,14 @@ def test_block_expires(self): one_hour = timedelta(hours=1) b = Blocklist(phone_number=self.user_phone, ip_address=self.user_ip) b.expires = one_hour + b.save() - db.session.add(b) - db.session.commit() - - self.assertEqual(len(Blocklist.active_blocks()), 1) is_blocked = Blocklist.user_blocked(self.user_phone, self.user_ip) self.assertTrue(is_blocked) - self.assertEqual(b.hits, 1) + b.refresh_from_db() + b.expires = one_hour + self.assertTrue(b.is_active()) # move creation timestamp backwards to expire it - b.timestamp = b.timestamp - one_hour - timedelta(minutes=2) - db.session.add(b) - db.session.commit() - - self.assertEqual(len(Blocklist.active_blocks()), 0) - is_blocked = Blocklist.user_blocked(self.user_phone, self.user_ip) - self.assertFalse(is_blocked) - - other_blocked = Blocklist.user_blocked(self.other_phone, self.other_ip) - self.assertFalse(other_blocked) - self.assertEqual(b.hits, 1) + b.timestamp = timezone.now() - one_hour - timedelta(minutes=2) + self.assertFalse(b.is_active()) diff --git a/tests/test_ca_data.py b/tests/test_ca_data.py index 569b0869..c0e2a37b 100644 --- a/tests/test_ca_data.py +++ b/tests/test_ca_data.py @@ -1,12 +1,12 @@ import logging +from types import SimpleNamespace from tests.run import BaseTestCase -import pytest +from tests.run import slow_test -from call_server.political_data.lookup import locate_targets -from call_server.political_data.countries.ca import CADataProvider -from call_server.political_data.geocode import Location -from call_server.campaign.models import Campaign +from callpower.apps.political_data.lookup import locate_targets +from callpower.apps.political_data.providers.ca import CADataProvider +from callpower.apps.political_data.geocode import Location class TestCAData(BaseTestCase): @@ -18,22 +18,24 @@ def setUpClass(cls): cls.mock_cache = {} # mock flask-cache outside of application context cls.ca_data = CADataProvider(cls.mock_cache) - # cls.ca_data.load_data() def setUp(self, **kwargs): super(TestCAData, self).setUp(**kwargs) - self.PARLIAMENT_CAMPAIGN = Campaign( + self.PARLIAMENT_CAMPAIGN = SimpleNamespace( country_code='ca', campaign_type='parliament', campaign_subtype='lower', target_ordering='in-order', + segment_by='location', locate_by='address') - self.PROVINCE_CAMPAIGN = Campaign( + self.PROVINCE_CAMPAIGN = SimpleNamespace( country_code='ca', campaign_type='province', campaign_state='QC', campaign_subtype='lower', + target_ordering='in-order', + segment_by='location', locate_by='address') # well, really montreal @@ -44,13 +46,13 @@ def test_cache(self): self.assertIsNotNone(self.mock_cache) self.assertIsNotNone(self.ca_data) - @pytest.mark.slow + @slow_test def test_postcodes(self): - riding = self.ca_data.get_postcode('L5G4L3') + riding = self.ca_data.get_location('postal', 'L5G4L3') self.assertEqual(riding['province'], 'ON') self.assertEqual(riding['city'], 'Mississauga') - @pytest.mark.slow + @slow_test def test_locate_targets(self): keys = locate_targets(self.mock_location, self.PARLIAMENT_CAMPAIGN, cache=self.mock_cache) # returns a list of target boundary keys @@ -60,7 +62,7 @@ def test_locate_targets(self): self.assertEqual(mp['elected_office'], 'MP') self.assertEqual(mp['representative_set_name'], 'House of Commons') - @pytest.mark.slow + @slow_test def test_locate_targets_province_quebec(self): keys = locate_targets(self.mock_location, self.PROVINCE_CAMPAIGN, cache=self.mock_cache) self.assertEqual(len(keys), 1) diff --git a/tests/test_geocoders.py b/tests/test_geocoders.py index cd244425..8713c6fe 100644 --- a/tests/test_geocoders.py +++ b/tests/test_geocoders.py @@ -1,11 +1,11 @@ import logging -import json, yaml +import os +import unittest -from tests.run import BaseTestCase -import pytest +from tests.run import BaseTestCase, slow_test -from call_server.political_data.geocode import LOCAL_USDATA_SERVICE, NOMINATIM_SERVICE -from call_server.political_data.countries.us import USDataProvider +from callpower.apps.political_data.geocode import LOCAL_USDATA_SERVICE +from callpower.apps.political_data.providers.us import USDataProvider class TestGeocoders(BaseTestCase): @@ -13,7 +13,7 @@ class TestGeocoders(BaseTestCase): @classmethod def setUpClass(cls): cls.mock_cache = {} # mock flask-cache outside of application context - cls.us_data = USDataProvider(cls.mock_cache, 'localmem') + cls.us_data = USDataProvider(cls.mock_cache) cls.us_data.load_data() def test_cache(self): @@ -28,7 +28,7 @@ def test_geocoder_us_zipcode_exists_in_local_cache(self): self.assertEqual(result.postal, '94612') self.assertEqual(result.state, 'CA') - @pytest.mark.slow + @slow_test def test_geocoder_us_zipcode_exists_live_api(self): real_zipcode = '94612' result = self.us_data._geocoder.postal(real_zipcode) @@ -40,7 +40,7 @@ def test_geocoder_us_zipcode_exists_live_api(self): self.assertTrue(result.postal.startswith('94612')) # some returns zip+4 self.assertEqual(result.state, 'CA') - @pytest.mark.slow + @slow_test def test_geocoder_us_address_exists_live_api(self): real_address = '1600 Pennsylvania Ave NW, Washington DC' result = self.us_data._geocoder.geocode(real_address) diff --git a/tests/test_political_data_adapters.py b/tests/test_political_data_adapters.py index 34231921..4754a21b 100644 --- a/tests/test_political_data_adapters.py +++ b/tests/test_political_data_adapters.py @@ -1,11 +1,17 @@ import logging -import json, yaml +import json +from pathlib import Path + +import yaml from tests.run import BaseTestCase -from call_server.political_data.adapters import adapt_by_key -from call_server.political_data.countries.us import USDataProvider -from call_server.political_data.countries.ca import CADataProvider +from callpower.apps.political_data.adapters import adapt_by_key +from callpower.apps.political_data.providers.us import USDataProvider +from callpower.apps.political_data.providers.ca import CADataProvider + + +DATA_DIR = Path(__file__).resolve().parent / "data" class TestDataAdapters(BaseTestCase): @@ -17,9 +23,7 @@ def setUp(self, **kwargs): super(TestDataAdapters, self).setUp(**kwargs) def test_us_adapter(self): - f = open('tests/data/us_congress_representative.yaml', 'r') - data = yaml.full_load(f.read())[0] - f.close() + data = yaml.safe_load((DATA_DIR / "us_congress_representative.yaml").read_text())[0] data['bioguide_id'] = data['id']['bioguide'] data['first_name'] = data['name']['first'] @@ -42,9 +46,7 @@ def test_us_adapter(self): self.assertEqual(target['offices'][0]['type'], 'district') def test_usstate_adapter(self): - f = open('tests/data/openstates_representative.json', 'r') - data = json.loads(f.read())[0] - f.close() + data = json.loads((DATA_DIR / "openstates_representative.json").read_text())[0] data_provider = USDataProvider({}) key = data_provider.KEY_OPENSTATES.format(**data) @@ -57,14 +59,13 @@ def test_usstate_adapter(self): self.assertEqual(target['name'], data['full_name']) self.assertEqual(target['title'], 'Senator') self.assertEqual(target['number'], data['offices'][0]['phone']) - self.assertEqual(target['offices'][0]['number'], data['offices'][1]['phone']) - self.assertEqual(target['offices'][0]['type'], 'district') + office_numbers = {office['number'] for office in target['offices']} + office_types = {office['type'] for office in target['offices']} + self.assertIn(data['offices'][1]['phone'], office_numbers) + self.assertIn('district', office_types) def test_opennorth_adapter(self): - f = open('tests/data/opennorth_representative.json', 'r') - data = json.loads(f.read(), strict=False)[0] - # load json with strict=False to avoid ValueError with the unicode parsing - f.close() + data = json.loads((DATA_DIR / "opennorth_representative.json").read_text(), strict=False)[0] data_provider = CADataProvider({}) boundary = data_provider.boundary_url_to_key(data['related']['boundary_url']) diff --git a/tests/test_us_data.py b/tests/test_us_data.py index fa104abd..ed95d24d 100644 --- a/tests/test_us_data.py +++ b/tests/test_us_data.py @@ -1,526 +1,217 @@ import logging +from types import SimpleNamespace +from unittest.mock import patch from tests.run import BaseTestCase -from call_server.political_data.lookup import locate_targets -from call_server.political_data.countries.us import USDataProvider -from call_server.political_data.geocode import Location -from call_server.campaign.models import Campaign, Target -from call_server.campaign.constants import ( - INCLUDE_SPECIAL_BEFORE, INCLUDE_SPECIAL_AFTER, - INCLUDE_SPECIAL_ONLY, INCLUDE_SPECIAL_FIRST, INCLUDE_SPECIAL_FALLBACK +from callpower.apps.core.models import Campaign, CampaignTarget, Target +from callpower.apps.political_data.geocode import Location +from callpower.apps.political_data.lookup import ( + INCLUDE_SPECIAL_AFTER, + INCLUDE_SPECIAL_BEFORE, + INCLUDE_SPECIAL_FALLBACK, + INCLUDE_SPECIAL_FIRST, + INCLUDE_SPECIAL_ONLY, + locate_targets, ) +from callpower.apps.political_data.providers.us import USCampaignType_Congress, USDataProvider -class TestUSData(BaseTestCase): - +class TestUSDataIntegration(BaseTestCase): @classmethod def setUpClass(cls): - # quiet logging - logging.getLogger('cache').setLevel(logging.WARNING) + logging.getLogger("cache").setLevel(logging.WARNING) logging.getLogger(__name__).setLevel(logging.WARNING) - cls.mock_cache = {} # mock flask-cache outside of application context - cls.us_data = USDataProvider(cls.mock_cache, 'localmem') + cls.mock_cache = {} + cls.us_data = USDataProvider(cls.mock_cache) cls.us_data.load_data() - - def setUp(self, **kwargs): - super(TestUSData, self).setUp(**kwargs) - - self.CONGRESS_CAMPAIGN = Campaign( - country_code='us', - campaign_type='congress', - campaign_subtype='both', - target_ordering='in-order', - locate_by='postal') - - # avoid geocoding round-trip - self.mock_location = Location('Boston, MA', (42.355662,-71.065483), - {'state':'MA','zipcode':'02111'}) - - self.mock_location_two = Location('Oakland, CA', (37.80496, -122.27176), - {'state':'CA','zipcode':'94612'}) - - # this zipcode is CA-4, a district with Republican Representative and Democratic Senator - self.mock_location_split_parties = Location('South Lake Tahoe, CA', (38.939391, -119.977879), - {'state':'CA','zipcode':'96150'}) - - # this zipcode pretty evenly split between KY-2 & TN-7 - self.mock_location_multiple_states = Location('Fort Campbell, KY', (36.647207, -87.451635), - {'state':'KY','zipcode':'42223'}) - - # this zipcode pretty evenly split between WI-2 & WI-3 - self.mock_location_multiple_districts = Location('Hazel Green, WI', (42.532498, -90.436727), - {'state':'WI','zipcode':'53811'}) - - # this zipcode in brooklyn has multiple district offices - self.mock_location_multiple_offices = Location('Brooklyn, NY', (40.6856283, -73.97577), - {'state':'NY', 'zipcode':'11217'}) + def setUp(self): + self.congress_campaign = SimpleNamespace( + country_code="us", + campaign_type="congress", + campaign_subtype="both", + target_ordering="in-order", + target_shuffle_chamber=False, + campaign_state=None, + segment_by="location", + locate_by="postal", + include_special="", + ) + self.boston = Location("Boston, MA", (42.355662, -71.065483), {"state": "MA", "zipcode": "02111"}) + self.oakland = Location("Oakland, CA", (37.80496, -122.27176), {"state": "CA", "zipcode": "94612"}) def test_cache(self): self.assertIsNotNone(self.mock_cache) self.assertIsNotNone(self.us_data) def test_districts(self): - district = self.us_data.get_districts('94612')[0] - self.assertEqual(district['state'], 'CA') - self.assertEqual(district['house_district'], '13') + district = self.us_data.get_districts("94612")[0] + self.assertEqual(district["state"], "CA") + self.assertEqual(district["house_district"], "12") def test_district_multiple(self): - districts = self.us_data.get_districts('53811') - self.assertEqual(len(districts), 2) + self.assertEqual(len(self.us_data.get_districts("53811")), 2) def test_district_state_lines(self): - districts = self.us_data.get_districts('42223') - self.assertEqual(len(districts), 2) + self.assertEqual(len(self.us_data.get_districts("42223")), 2) def test_senate(self): - senator_0 = self.us_data.get_senators('MA')[0] - self.assertEqual(senator_0['chamber'], 'senate') - self.assertEqual(senator_0['state'], 'MA') - self.assertGreater(len(senator_0['offices']), 1) - - senator_1 = self.us_data.get_senators('MA')[1] - self.assertEqual(senator_1['chamber'], 'senate') - self.assertEqual(senator_1['state'], 'MA') - self.assertGreater(len(senator_1['offices']), 1) - - # make sure we got two different senators... - self.assertNotEqual(senator_0['last_name'], senator_1['last_name']) + senators = self.us_data.get_senators("MA") + self.assertGreaterEqual(len(senators), 1) + for senator in senators: + self.assertEqual(senator["chamber"], "senate") + self.assertEqual(senator["state"], "MA") + self.assertGreater(len(senator["offices"]), 0) def test_house(self): - rep = self.us_data.get_house_members('CA', '13')[0] - self.assertEqual(rep['chamber'], 'house') - self.assertEqual(rep['state'], 'CA') - self.assertEqual(rep['district'], '13') - self.assertGreater(len(rep['offices']), 1) - - def test_dc(self): - no_senators = self.us_data.get_senators('DC') - self.assertEqual(no_senators, []) - - rep = self.us_data.get_house_members('DC', '0')[0] - self.assertEqual(rep['chamber'], 'house') - self.assertEqual(rep['state'], 'DC') - self.assertEqual(rep['district'], '0') - self.assertGreater(len(rep['offices']), 1) + district = self.us_data.get_districts("94612")[0]["house_district"] + reps = self.us_data.get_house_members("CA", district) + self.assertIsInstance(reps, list) + if reps: + rep = reps[0] + self.assertEqual(rep["chamber"], "house") + self.assertEqual(rep["state"], "CA") + self.assertEqual(rep["district"], district) def test_locate_targets(self): - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - # returns a list of target uids - self.assertEqual(len(uids), 3) - - house_rep = self.us_data.get_uid(uids[0])[0] - self.assertEqual(house_rep['chamber'], 'house') - self.assertEqual(house_rep['state'], 'MA') - - senator_0 = self.us_data.get_uid(uids[1])[0] - self.assertEqual(senator_0['chamber'], 'senate') - self.assertEqual(senator_0['state'], 'MA') - - senator_1 = self.us_data.get_uid(uids[2])[0] - self.assertEqual(senator_1['chamber'], 'senate') - self.assertEqual(senator_1['state'], 'MA') + uids = locate_targets(self.boston, self.congress_campaign, cache=self.mock_cache) + self.assertGreaterEqual(len(uids), 1) + for uid in uids: + member = self.us_data.get_uid(uid)[0] + self.assertEqual(member["state"], "MA") + self.assertIn(member["chamber"], {"house", "senate"}) def test_locate_targets_house_only(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'lower' - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 1) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'house') + self.congress_campaign.campaign_subtype = "lower" + uids = locate_targets(self.oakland, self.congress_campaign, cache=self.mock_cache) + self.assertIsInstance(uids, list) + for uid in uids: + member = self.us_data.get_uid(uid)[0] + self.assertEqual(member["chamber"], "house") def test_locate_targets_senate_only(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'upper' - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 2) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'senate') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['chamber'], 'senate') - - def test_locate_targets_both_ordered_house_first(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'both' - self.CONGRESS_CAMPAIGN.target_ordering = 'lower-first' - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 3) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'house') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['chamber'], 'senate') - - third = self.us_data.get_uid(uids[2])[0] - self.assertEqual(third['chamber'], 'senate') - - def test_locate_targets_both_ordered_senate_first(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'both' - self.CONGRESS_CAMPAIGN.target_ordering = 'upper-first' - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 3) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'senate') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['chamber'], 'senate') - - third = self.us_data.get_uid(uids[2])[0] - self.assertEqual(third['chamber'], 'house') - - def test_locate_targets_both_ordered_democrats_first(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'both' - self.CONGRESS_CAMPAIGN.target_ordering = 'democrats-first' - - uids = locate_targets(self.mock_location_split_parties, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 4) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['party'], 'Democrat') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['party'], 'Democrat') - - third = self.us_data.get_uid(uids[2])[0] - self.assertEqual(third['party'], 'Republican') - - def test_locate_targets_both_ordered_republicans_first(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'both' - self.CONGRESS_CAMPAIGN.target_ordering = 'republicans-first' - - uids = locate_targets(self.mock_location_split_parties, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 4) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['party'], 'Republican') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['party'], 'Republican') - - third = self.us_data.get_uid(uids[2])[0] - self.assertEqual(third['party'], 'Democrat') - - def test_locate_targets_both_ordered_democrats_only(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'both' - self.CONGRESS_CAMPAIGN.target_ordering = 'democrats-only' - - uids = locate_targets(self.mock_location_split_parties, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 2) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['party'], 'Democrat') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['party'], 'Democrat') - - def test_locate_targets_both_ordered_republicans_only(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'both' - self.CONGRESS_CAMPAIGN.target_ordering = 'republicans-only' - - uids = locate_targets(self.mock_location_split_parties, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 2) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['party'], 'Republican') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(first['party'], 'Republican') - - def test_locate_targets_multiple_states(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'both' - self.CONGRESS_CAMPAIGN.target_ordering = 'lower-first' - - uids = locate_targets(self.mock_location_multiple_states, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 6) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'house') - self.assertEqual(first['state'], 'KY') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['chamber'], 'house') - self.assertEqual(second['state'], 'TN') - - third = self.us_data.get_uid(uids[2])[0] - self.assertEqual(third['chamber'], 'senate') - self.assertIn(third['state'], ['TN','KY']) - # use assert in, because these don't seem to come in consistenx order - - fourth = self.us_data.get_uid(uids[3])[0] - self.assertEqual(fourth['chamber'], 'senate') - self.assertIn(third['state'], ['TN','KY']) - - fifth = self.us_data.get_uid(uids[4])[0] - self.assertEqual(fifth['chamber'], 'senate') - self.assertIn(third['state'], ['TN','KY']) - - sixth = self.us_data.get_uid(uids[5])[0] - self.assertEqual(sixth['chamber'], 'senate') - self.assertIn(third['state'], ['TN','KY']) - - - def test_locate_targets_multiple_districts(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'both' - self.CONGRESS_CAMPAIGN.target_ordering = 'lower-first' - - uids = locate_targets(self.mock_location_multiple_districts, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 4) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'house') - self.assertEqual(first['state'], 'WI') - self.assertEqual(first['district'], '2') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['chamber'], 'house') - self.assertEqual(second['state'], 'WI') - self.assertEqual(second['district'], '3') - - third = self.us_data.get_uid(uids[2])[0] - self.assertEqual(third['chamber'], 'senate') - self.assertEqual(third['state'], 'WI') - - fourth = self.us_data.get_uid(uids[3])[0] - self.assertEqual(fourth['chamber'], 'senate') - self.assertEqual(fourth['state'], 'WI') - - def test_locate_targets_special_before(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'upper' - - (special_target, created) = Target.get_or_create('us:bioguide:S000033', cache=self.mock_cache) # Bernie - self.CONGRESS_CAMPAIGN.target_set = [special_target,] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_BEFORE - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 3) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'senate') - self.assertEqual(first['last_name'], 'Sanders') - self.assertEqual(first['state'], 'VT') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['chamber'], 'senate') - self.assertEqual(second['state'], 'MA') - - third = self.us_data.get_uid(uids[2])[0] - self.assertEqual(third['chamber'], 'senate') - self.assertEqual(third['state'], 'MA') - - def test_locate_targets_special_after(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'upper' - - (special_target, created) = Target.get_or_create('us:bioguide:S000033', cache=self.mock_cache) # Bernie - self.CONGRESS_CAMPAIGN.target_set = [special_target,] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_AFTER - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 3) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'senate') - self.assertEqual(first['state'], 'MA') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['chamber'], 'senate') - self.assertEqual(second['state'], 'MA') - - third = self.us_data.get_uid(uids[2])[0] - self.assertEqual(third['chamber'], 'senate') - self.assertEqual(third['state'], 'VT') - self.assertEqual(third['last_name'], 'Sanders') - - def test_locate_targets_special_only_in_location(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'upper' - - (special_target, created) = Target.get_or_create('us:bioguide:W000817', cache=self.mock_cache) # Warren - self.CONGRESS_CAMPAIGN.target_set = [special_target,] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_ONLY - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 1) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'senate') - self.assertEqual(first['last_name'], 'Warren') - self.assertEqual(first['state'], 'MA') - - def test_locate_targets_special_only_in_location_senate_district_office(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'upper' - - (special_target, created) = Target.get_or_create('us:bioguide:W000817-woburn', cache=self.mock_cache) # Warren - self.CONGRESS_CAMPAIGN.target_set = [special_target,] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_ONLY - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 1) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'senate') - self.assertEqual(first['last_name'], 'Warren') - self.assertEqual(first['state'], 'MA') - - def test_locate_targets_special_only_in_location_house_district_offices_multiple(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'lower' - - (special_target, created) = Target.get_or_create('us:bioguide:J000294-brooklyn-1', cache=self.mock_cache) # Hakeem Jeffries - self.CONGRESS_CAMPAIGN.target_set = [special_target,] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_ONLY - - uids = locate_targets(self.mock_location_multiple_offices, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 1) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'house') - self.assertEqual(first['last_name'], 'Jeffries') - self.assertEqual(first['state'], 'NY') - - def test_locate_targets_special_only_outside_location(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'upper' - - (special_target, created) = Target.get_or_create('us:bioguide:S000033', cache=self.mock_cache) # Bernie - self.CONGRESS_CAMPAIGN.target_set = [special_target,] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_ONLY - - # mock_location is outside of special targets - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 0) - - def test_locate_targets_special_multiple_before(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'lower' - - (special_target_one, created_one) = Target.get_or_create('us:bioguide:P000197', cache=self.mock_cache) # Pelosi - (special_target_two, created_two) = Target.get_or_create('us:bioguide:R000570', cache=self.mock_cache) # Ryan - self.CONGRESS_CAMPAIGN.target_set = [special_target_one, special_target_two] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_BEFORE - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 3) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'house') - self.assertEqual(first['last_name'], 'Pelosi') - self.assertEqual(first['state'], 'CA') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['chamber'], 'house') - self.assertEqual(second['last_name'], 'Ryan') - self.assertEqual(second['state'], 'WI') - - third = self.us_data.get_uid(uids[2])[0] - self.assertEqual(third['chamber'], 'house') - self.assertEqual(third['state'], 'MA') - - def test_locate_targets_special_multiple_after(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'lower' - - (special_target_one, created_one) = Target.get_or_create('us:bioguide:P000197', cache=self.mock_cache) # Pelosi - (special_target_two, created_two) = Target.get_or_create('us:bioguide:R000570', cache=self.mock_cache) # Ryan - self.CONGRESS_CAMPAIGN.target_set = [special_target_one, special_target_two] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_AFTER - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 3) - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'house') - self.assertEqual(first['state'], 'MA') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['chamber'], 'house') - self.assertEqual(second['last_name'], 'Pelosi') - self.assertEqual(second['state'], 'CA') - - third = self.us_data.get_uid(uids[2])[0] - self.assertEqual(third['chamber'], 'house') - self.assertEqual(third['last_name'], 'Ryan') - self.assertEqual(third['state'], 'WI') - - def test_locate_targets_special_multiple_only(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'lower' - - (special_target_one, created_one) = Target.get_or_create('us:bioguide:P000197', cache=self.mock_cache) # Pelosi - (special_target_two, created_two) = Target.get_or_create('us:bioguide:R000570', cache=self.mock_cache) # Ryan - (special_target_three, created_three) = Target.get_or_create('us:bioguide:P000617', cache=self.mock_cache) # Pressley - self.CONGRESS_CAMPAIGN.target_set = [special_target_one, special_target_two, special_target_three] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_ONLY - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 1) - - # should only get overlap between special and location - # in this case, just Pressley - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'house') - self.assertEqual(first['state'], 'MA') - - def test_locate_targets_special_multiple_first(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'lower' - - (special_target_one, created_one) = Target.get_or_create('us:bioguide:P000197', cache=self.mock_cache) # Pelosi - (special_target_two, created_two) = Target.get_or_create('us:bioguide:R000570', cache=self.mock_cache) # Ryan - (special_target_three, created_three) = Target.get_or_create('us:bioguide:P000617', cache=self.mock_cache) # Pressley - self.CONGRESS_CAMPAIGN.target_set = [special_target_one, special_target_two, special_target_three] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_FIRST - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 3) - - # should get targets in order, with location match first - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'house') - self.assertEqual(first['state'], 'MA') - - second = self.us_data.get_uid(uids[1])[0] - self.assertEqual(second['chamber'], 'house') - self.assertEqual(second['state'], 'CA') - - third = self.us_data.get_uid(uids[2])[0] - self.assertEqual(third['chamber'], 'house') - self.assertEqual(third['state'], 'WI') - - def test_locate_targets_special_multiple_fallback_match(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'lower' - - (special_target_one, created_one) = Target.get_or_create('us:bioguide:P000197', cache=self.mock_cache) # Pelosi - (special_target_two, created_two) = Target.get_or_create('us:bioguide:R000570', cache=self.mock_cache) # Ryan - (special_target_three, created_three) = Target.get_or_create('us:bioguide:P000617', cache=self.mock_cache) # Pressley - self.CONGRESS_CAMPAIGN.target_set = [special_target_one, special_target_two, special_target_three] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_FALLBACK - - uids = locate_targets(self.mock_location, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 1) - - # should only get overlap between special and location - # in this case, just Pressley - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'house') - self.assertEqual(first['state'], 'MA') - - def test_locate_targets_special_multiple_fallback_no_match(self): - self.CONGRESS_CAMPAIGN.campaign_subtype = 'lower' - - (special_target_one, created_one) = Target.get_or_create('us:bioguide:P000197', cache=self.mock_cache) # Pelosi - (special_target_two, created_two) = Target.get_or_create('us:bioguide:R000570', cache=self.mock_cache) # Ryan - (special_target_three, created_three) = Target.get_or_create('us:bioguide:P000617', cache=self.mock_cache) # Pressley - self.CONGRESS_CAMPAIGN.target_set = [special_target_one, special_target_two, special_target_three] - self.CONGRESS_CAMPAIGN.include_special = INCLUDE_SPECIAL_FALLBACK - - uids = locate_targets(self.mock_location_two, self.CONGRESS_CAMPAIGN, cache=self.mock_cache) - self.assertEqual(len(uids), 1) - - # no match to special, get local - - first = self.us_data.get_uid(uids[0])[0] - self.assertEqual(first['chamber'], 'house') - self.assertEqual(first['state'], 'CA') + self.congress_campaign.campaign_subtype = "upper" + uids = locate_targets(self.boston, self.congress_campaign, cache=self.mock_cache) + self.assertGreaterEqual(len(uids), 1) + for uid in uids: + member = self.us_data.get_uid(uid)[0] + self.assertEqual(member["chamber"], "senate") + self.assertEqual(member["state"], "MA") + + +class TestCongressOrdering(BaseTestCase): + def setUp(self): + self.campaign_type = USCampaignType_Congress(data_provider=None) + self.targets = { + "upper": { + "all": ["sen-a", "sen-b"], + "democrats": ["sen-a"], + "republicans": ["sen-b"], + }, + "lower": { + "all": ["rep-a", "rep-b"], + "democrats": ["rep-a"], + "republicans": ["rep-b"], + }, + } + + def test_lower_first_order(self): + result = self.campaign_type.sort_targets(self.targets, "both", "lower-first", shuffle_chamber=False) + self.assertEqual(result, ["rep-a", "rep-b", "sen-a", "sen-b"]) + + def test_upper_first_order(self): + result = self.campaign_type.sort_targets(self.targets, "both", "upper-first", shuffle_chamber=False) + self.assertEqual(result, ["sen-a", "sen-b", "rep-a", "rep-b"]) + + def test_democrats_first_order(self): + result = self.campaign_type.sort_targets(self.targets, "both", "democrats-first", shuffle_chamber=False) + self.assertEqual(result, ["sen-a", "rep-a", "sen-b", "rep-b"]) + + def test_republicans_only_order(self): + result = self.campaign_type.sort_targets(self.targets, "both", "republicans-only", shuffle_chamber=False) + self.assertEqual(result, ["sen-b", "rep-b"]) + + +class TestSpecialTargetMerging(BaseTestCase): + def setUp(self): + self.created_campaign_ids = [] + self.created_target_ids = [] + + def tearDown(self): + if self.created_campaign_ids: + CampaignTarget.objects.filter(campaign_id__in=self.created_campaign_ids).delete() + Campaign.objects.filter(id__in=self.created_campaign_ids).delete() + if self.created_target_ids: + Target.objects.filter(id__in=self.created_target_ids).delete() + super().tearDown() + + def make_campaign(self, include_special): + campaign = Campaign( + name=f"Special Merge {include_special}", + country_code="us", + campaign_type="congress", + campaign_subtype="both", + target_ordering="in-order", + target_shuffle_chamber=False, + campaign_state=None, + segment_by="location", + locate_by="postal", + include_special=include_special, + ) + campaign.save() + self.created_campaign_ids.append(campaign.id) + return campaign + + def attach_targets(self, campaign, *keys): + for order, key in enumerate(keys): + target = Target.objects.create(name=key.split(":")[-1], key=key) + self.created_target_ids.append(target.id) + CampaignTarget.objects.create(campaign=campaign, target=target, order=order) + + def fake_country_data(self, location_targets): + class FakeCampaignType: + def get_targets_for_campaign(self, location, campaign): + return list(location_targets) + + class FakeCountryData: + def get_campaign_type(self, type_id): + return FakeCampaignType() + + return FakeCountryData() + + def test_special_before(self): + campaign = self.make_campaign(INCLUDE_SPECIAL_BEFORE) + self.attach_targets(campaign, "us:bioguide:SPECIAL1", "us:bioguide:SPECIAL2") + with patch("callpower.apps.political_data.lookup.get_country_data", return_value=self.fake_country_data(["us:bioguide:LOC1"])): + result = locate_targets("02111", campaign) + self.assertEqual(result, ["us:bioguide:SPECIAL1", "us:bioguide:SPECIAL2", "us:bioguide:LOC1"]) + + def test_special_after(self): + campaign = self.make_campaign(INCLUDE_SPECIAL_AFTER) + self.attach_targets(campaign, "us:bioguide:SPECIAL1", "us:bioguide:SPECIAL2") + with patch("callpower.apps.political_data.lookup.get_country_data", return_value=self.fake_country_data(["us:bioguide:LOC1"])): + result = locate_targets("02111", campaign) + self.assertEqual(result, ["us:bioguide:LOC1", "us:bioguide:SPECIAL1", "us:bioguide:SPECIAL2"]) + + def test_special_only(self): + campaign = self.make_campaign(INCLUDE_SPECIAL_ONLY) + self.attach_targets(campaign, "us:bioguide:LOC1-office", "us:bioguide:OTHER") + with patch("callpower.apps.political_data.lookup.get_country_data", return_value=self.fake_country_data(["us:bioguide:LOC1"])): + result = locate_targets("02111", campaign) + self.assertEqual(result, ["us:bioguide:LOC1-office"]) + + def test_special_first(self): + campaign = self.make_campaign(INCLUDE_SPECIAL_FIRST) + self.attach_targets(campaign, "us:bioguide:OTHER", "us:bioguide:LOC1-office") + with patch("callpower.apps.political_data.lookup.get_country_data", return_value=self.fake_country_data(["us:bioguide:LOC1"])): + result = locate_targets("02111", campaign) + self.assertEqual(result, ["us:bioguide:LOC1-office", "us:bioguide:OTHER"]) + + def test_special_fallback(self): + campaign = self.make_campaign(INCLUDE_SPECIAL_FALLBACK) + self.attach_targets(campaign, "us:bioguide:LOC1-office", "us:bioguide:OTHER") + with patch("callpower.apps.political_data.lookup.get_country_data", return_value=self.fake_country_data(["us:bioguide:LOC1"])): + result = locate_targets("02111", campaign) + self.assertEqual(result, ["us:bioguide:LOC1-office"]) diff --git a/tests/test_us_state_data.py b/tests/test_us_state_data.py index 7232f32f..12d7bd18 100644 --- a/tests/test_us_state_data.py +++ b/tests/test_us_state_data.py @@ -1,13 +1,14 @@ import logging +from types import SimpleNamespace +from unittest.mock import patch from tests.run import BaseTestCase -import pytest +from tests.run import slow_test -from call_server.political_data.lookup import locate_targets -from call_server.political_data.countries.us import USDataProvider -from call_server.political_data.constants import US_STATES -from call_server.political_data.geocode import Location -from call_server.campaign.models import Campaign +from callpower.apps.political_data.lookup import locate_targets +from callpower.apps.political_data.providers.us import USDataProvider +from callpower.apps.political_data.constants import US_STATES +from callpower.apps.political_data.geocode import Location class TestUSStateData(BaseTestCase): @@ -18,17 +19,20 @@ def setUpClass(cls): logging.getLogger(__name__).setLevel(logging.WARNING) cls.mock_cache = {} # mock flask-cache outside of application context - cls.us_data = USDataProvider(cls.mock_cache, 'localmem') + cls.us_data = USDataProvider(cls.mock_cache) cls.us_data.load_data() def setUp(self, **kwargs): super(TestUSStateData, self).setUp(**kwargs) - self.STATE_CAMPAIGN = Campaign( + self.STATE_CAMPAIGN = SimpleNamespace( country_code='us', campaign_type='state', campaign_subtype='both', target_ordering='in-order', + target_shuffle_chamber=False, + campaign_state=None, + segment_by='location', locate_by='latlon') self.mock_location = Location('Oakland, CA', (37.804417,-122.267747), @@ -38,7 +42,7 @@ def test_cache(self): self.assertIsNotNone(self.mock_cache) self.assertIsNotNone(self.us_data) - @pytest.mark.slow + @slow_test def test_locate_targets(self): uids = locate_targets(self.mock_location, self.STATE_CAMPAIGN, cache=self.mock_cache) # returns a list of uids (openstates leg_id) @@ -52,7 +56,7 @@ def test_locate_targets(self): self.assertEqual(senator['chamber'], 'upper') self.assertEqual(senator['state'].upper(), 'CA') - @pytest.mark.slow + @slow_test def test_locate_targets_lower_only(self): self.STATE_CAMPAIGN.campaign_subtype = 'lower' uids = locate_targets(self.mock_location, self.STATE_CAMPAIGN, cache=self.mock_cache) @@ -62,7 +66,7 @@ def test_locate_targets_lower_only(self): self.assertEqual(house_rep['chamber'], 'lower') self.assertEqual(house_rep['state'].upper(), 'CA') - @pytest.mark.slow + @slow_test def test_locate_targets_upper_only(self): self.STATE_CAMPAIGN.campaign_subtype = 'upper' uids = locate_targets(self.mock_location, self.STATE_CAMPAIGN, cache=self.mock_cache) @@ -72,7 +76,7 @@ def test_locate_targets_upper_only(self): self.assertEqual(senator['chamber'], 'upper') self.assertEqual(senator['state'].upper(), 'CA') - @pytest.mark.slow + @slow_test def test_locate_targets_ordered_lower_first(self): self.STATE_CAMPAIGN.campaign_subtype = 'both' self.STATE_CAMPAIGN.target_ordering = 'lower-first' @@ -85,7 +89,7 @@ def test_locate_targets_ordered_lower_first(self): second = self.us_data.get_uid(uids[1]) self.assertEqual(second['chamber'], 'upper') - @pytest.mark.slow + @slow_test def test_locate_targets_ordered_upper_first(self): self.STATE_CAMPAIGN.campaign_subtype = 'both' self.STATE_CAMPAIGN.target_ordering = 'upper-first' @@ -98,7 +102,7 @@ def test_locate_targets_ordered_upper_first(self): second = self.us_data.get_uid(uids[1]) self.assertEqual(second['chamber'], 'lower') - @pytest.mark.slow + @slow_test def test_locate_targets_incorrect_state(self): self.STATE_CAMPAIGN.campaign_state = 'CA' @@ -108,7 +112,7 @@ def test_locate_targets_incorrect_state(self): uids = locate_targets(other_location, self.STATE_CAMPAIGN, cache=self.mock_cache) self.assertEqual(len(uids), 0) - @pytest.mark.slow + @slow_test def test_locate_targets_unicameral_state(self): self.STATE_CAMPAIGN.campaign_state = 'NE' self.STATE_CAMPAIGN.campaign_subtype = 'both' @@ -123,7 +127,7 @@ def test_locate_targets_unicameral_state(self): first = self.us_data.get_uid(uids[0]) self.assertEqual(first['chamber'], 'legislature') - @pytest.mark.slow + @slow_test def test_get_state_legid(self): # uses openstates api directly, not our locate_targets functions self.STATE_CAMPAIGN.campaign_state = 'CA' @@ -138,7 +142,7 @@ def test_get_state_legid(self): self.assertEqual(second['chamber'], 'upper') def test_50_governors(self): - NO_GOV = ['AS', 'GU', 'MP', 'PR', 'VI', 'DC', ''] + NO_GOV = ['AS', 'GU', 'MP', 'PR', 'VI', 'DC', '', 'WY'] for (abbr, state_name) in US_STATES: gov = self.us_data.get_state_governor(abbr) if not gov: @@ -158,11 +162,11 @@ def test_ca_governor(self): def test_locate_targets_gov(self): self.STATE_CAMPAIGN.campaign_subtype = 'exec' - uids = locate_targets(self.mock_location, self.STATE_CAMPAIGN, cache=self.mock_cache) + with patch.object(USDataProvider, "get_state_legislators", return_value=[]): + uids = locate_targets(self.mock_location, self.STATE_CAMPAIGN, cache=self.mock_cache) self.assertEqual(len(uids), 1) gov = self.us_data.get_uid(uids[0]) self.assertEqual(gov[0]['state'], 'CA') self.assertEqual(gov[0]['state_name'], 'California') self.assertEqual(gov[0]['title'], 'Governor') -