U h@sddlZddlZddlZddlZddlZddlZddlmZddlm Z ddl m Z ddlm Z ddl mZddlmZmZddlmZmZmZmZdd lmZmZdd lmZdd lmZdd lmZdd l m!Z!m"Z"ddl#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6m7Z7ddl8m9Z9m:Z:m;Z;mZ>Gddde$eZ?Gddde$eZ@Gddde$eZAGddde$eZBGd d!d!e$eZCGd"d#d#e$eZDdS)$N)View) connectiontimezone) transaction)messages) reverse_lazyreverse)QCountMaxMin) HttpResponse JsonResponse)PermissionDenied)method_decorator) csrf_protect)ListView UpdateView)LoginRequiredMixin)login_required)require_http_methods)get_object_or_404renderredirect) Paginator EmptyPagePageNotAnInteger)APIView) get_client_ip)Channel ChannelZone) PlaylistsWindowsAvailsAdspotsInAvail)PlaylistXMLGeneratorc@sreZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ dddZddZdS)PlaylistCreateViewu Django class-based view for comprehensive playlist creation and management operations. This view provides a complete interface for playlist creation, supporting both immediate playlist activation and draft playlist functionality. It handles the full lifecycle of playlist creation from initial form display through validation, processing, and final activation or storage. The view integrates with Django's authentication system to ensure only authenticated users can create playlists, and implements proper data isolation so users can only work with their own channels and zones. Inheritance: LoginRequiredMixin: Ensures only authenticated users can access this view Automatically redirects unauthenticated users to login page View: Django's base class-based view providing HTTP method dispatch Supported HTTP Methods: GET: Renders the playlist creation form with user's available channels POST: Processes form submission for playlist creation (apply or draft) Features: - User authentication and authorization - Channel and zone validation - Date parsing and validation - Dual submission modes (immediate apply vs draft) - Comprehensive error handling with user feedback - Data integrity validation - Secure data isolation per user URL Pattern: Typically mapped to: /playlists/create/ or similar Template: Uses: playlists/new.html Context Data: - channels: QuerySet of user's available channels Form Processing Flow: 1. User accesses GET endpoint → Display creation form 2. User fills form and clicks button → POST to same endpoint 3. System validates all input data → Extract common data 4. Route to appropriate handler → Process apply or draft 5. Redirect to success page → Display confirmation message Security Considerations: - LoginRequiredMixin prevents unauthorized access - Channel filtering by user ownership - CSRF protection through Django middleware - Input validation and sanitization - Error message sanitization to prevent XSS Error Handling: - Invalid channel/zone combinations - Malformed date inputs - Missing required fields - Database connectivity issues - User permission violations Dependencies: - Django authentication system - Channels model with user relationship - ChannelsZone model with channel relationship - Django messaging framework - Template rendering system Example Usage: # URL configuration path('create/', PlaylistCreateView.as_view(), name='new_playlist') # Template usage
{% csrf_token %}
Related Models: - Channels: Stores channel information with user relationships - ChannelsZone: Defines zones within channels - User: Django's authentication user model - Playlist: The target model for created playlists (implied) Performance Considerations: - Database queries are filtered and optimized - Single query for channels per GET request - Lazy evaluation of QuerySets - Proper indexing assumed on foreign key relationships Extensibility: - Additional validation can be added to _extract_common_data - New submission types can be added alongside apply/draft - Template can be customized for different UI frameworks - Additional context data can be passed to template Version History: - Initial implementation: Basic playlist creation - Added draft functionality: Save incomplete playlists - Enhanced validation: Comprehensive input checking - Improved error handling: User-friendly error messages cCs(|j}tjj|d}d|i}t|d|S)a Handle GET requests for playlist creation page rendering. This method processes GET requests to display the playlist creation form. It retrieves all channels associated with the authenticated user and prepares the context data needed for rendering the playlist creation interface. The method ensures users can only see and work with channels they own, maintaining proper data isolation and security. The rendered page will contain form elements populated with the user's available channels. Args: request (HttpRequest): Django HTTP request object containing: - User authentication information - Session data - GET parameters (if any) - HTTP headers and metadata Returns: HttpResponse: Rendered HTML response containing: - Playlist creation form - User's available channels in dropdown/selection elements - Associated JavaScript and CSS for form functionality - CSRF tokens for secure form submission Raises: AttributeError: If request.user is not available (authentication middleware issue) TemplateDoesNotExist: If 'playlists/new.html' template is missing Template Context: channels (QuerySet): Filtered list of Channel objects owned by current user Example: GET /playlist/create/ Response: HTML page with form containing: - Channel selection dropdown - Zone selection (populated via AJAX based on channel) - Date picker for playlist scheduling - Number of windows input - Submit buttons (Apply/Draft) Security: - Channels are filtered by user ownership (id_user=user) - Only authenticated users can access this view - CSRF protection enabled through Django middleware id_userchannelszplaylists/new.html)userr objectsfilterr)selfrequestr+r*contextr1//var/www/html/Focus/src/apps/playlists/views.pygets 8   zPlaylistCreateView.getcCsR|j}|jd}|jd}|r.|||S|r>|||St|dtdS)a Handle POST requests for playlist creation and management operations. This method serves as the main entry point for processing playlist form submissions. It determines the user's intended action (apply or draft) based on which submit button was clicked, then delegates to the appropriate handler method for processing. The method supports two primary workflows: 1. Apply Playlist: Immediately processes and activates the playlist 2. Draft Playlist: Saves the playlist as a draft for later modification Args: request (HttpRequest): Django HTTP request object containing: - POST data with form fields - User authentication information - Session data Expected POST fields: - 'apply_btn': Present if "Submit Playlist" button clicked - 'draft_btn': Present if "Save as Draft" button clicked - Additional playlist data fields Returns: HttpResponseRedirect: Redirect response to appropriate page: - On apply action: Redirects based on _handle_apply_playlist result - On draft action: Redirects based on _handle_draft_playlist result - On invalid submission: Redirects to playlist list with error message Raises: AttributeError: If request.user is not available (should not occur in normal flow) Example: POST /playlist/create/ Form data: { 'apply_btn': 'Submit Playlist', 'channel_id': '123', 'zonename': 'zone1', 'numofwin': '5', 'day': '07/30/2025' } Flow: 1. Extract user from request 2. Determine which button was clicked 3. Route to appropriate handler method 4. Return redirect response apply_btn draft_btnzRInvalid submission. Please use either 'Save as Draft' or 'Submit Playlist' button.playlists:list_playlist)r+POSTr3_handle_apply_playlist_handle_draft_playlistrerrorr)r.r/r+r4r5r1r1r2posts6    zPlaylistCreateView.postc Csz8|jd}|s(t|dtdWStjj|d}Wnltjk rbt|dtdYStk r}z&t|dt |tdWYSd}~XYnXz@|jdd  }|st|d tdWSt jj||d }Wnpt jk rt|d tdYStk rV}z&t|d t |tdWYSd}~XYnXz4|jd}|st|dtdWSt |Wnnt k rt|dtdYStk r}z&t|dt |tdWYSd}~XYnXz:|jd}|s&t|dtdWStj|d}Wnnt k r`t|dtdYStk r}z&t|dt |tdWYSd}~XYnX|||||dS)a@ Extract and validate common data from POST request for playlist operations. This method processes form data submitted via POST request and validates each field to ensure data integrity before proceeding with playlist operations. It handles channel selection, zone configuration, window count, and date formatting with comprehensive error handling and user feedback. Args: request (HttpRequest): Django HTTP request object containing POST data Expected POST fields: - 'channel_id': Unique identifier for the channel - 'zonename': Zone identifier within the channel - 'numofwin': Number of windows (must be numeric) - 'day': Date in MM/DD/YYYY format Returns: dict or HttpResponseRedirect: On success, returns dictionary with validated data: { 'channel_id': str - The channel identifier 'channel': Channels - Channel model instance 'channel_zone': ChannelsZone - Channel zone model instance 'number_of_windows': str - Number of windows value 'daydate': datetime - Parsed datetime object } On error, returns redirect to 'playlists:new_playlist' with error message Raises: Channels.DoesNotExist: When specified channel doesn't exist in database ChannelsZone.DoesNotExist: When specified zone doesn't exist for the channel ValueError: When date format is invalid or number_of_windows is not numeric Exception: For any other unexpected errors during processing Example: >>> data = self._extract_common_data(request) >>> if isinstance(data, dict): ... # Process successful data extraction ... channel = data['channel'] ... date = data['daydate'] >>> else: ... # Handle redirect response ... return data channel_idzChannel ID is required.zplaylists:new_playlist id_channelz Selected channel does not exist.zError retrieving channel: NzonenamezChannel Zone name is required.r>id_zone_channelz.Selected zone does not exist for this channel.zError retrieving channel zone: numofwinzNumber of windows is required.z)Number of windows must be a valid number.z$Error processing number of windows: dayzDate is required.%m/%d/%Yz2Invalid date format. Please use MM/DD/YYYY format.zError processing date: )r<channel channel_zonenumber_of_windowsdaydate)r7r3rr:rr r, DoesNotExist Exceptionstrstripr!int ValueErrordatetimestrptime) r.r/r<rFer?rGrHrIr1r1r2_extract_common_dataQsr1                      z'PlaylistCreateView._extract_common_datac Cst}||}|jd}tjj|dd|d|djddddtj j d|djddddtj j d|d d dd }| |||d|d |j |t |d ddtt|ddt}|j|d}t|td|jdS)a` Handle immediate playlist application and activation (non-draft processing). This method processes a complete playlist creation workflow including validation, database record creation, structural processing, activity logging, XML generation, and optional FTP deployment. It creates an active playlist that is immediately ready for broadcast scheduling. The method performs the complete playlist lifecycle in a single transaction-like operation, ensuring data consistency and providing comprehensive error handling with detailed logging for troubleshooting and auditing purposes. Args: request (HttpRequest): Django HTTP request object containing: - POST data with validated form fields - User session information - CSRF tokens and security headers - Optional draft_version for playlist updates user (User): Django User model instance representing the authenticated user Used for permissions, logging, and audit trail creation Returns: HttpResponseRedirect: Redirect to playlist detail page showing: - Created playlist information - Generated schedule details - XML output preview - Success confirmation message URL pattern: "playlists:playlist_detail" with playlist ID parameter Raises: ValidationError: If _extract_common_data validation fails IntegrityError: If playlist creation violates database constraints AttributeError: If required model relationships are missing Exception: For XML generation or FTP upload failures Database Operations: - Creates new Playlists record with version 1 - Processes playlist structure (windows, avails, ads) - Logs activity record for audit trail - Maintains referential integrity across related models Processing Flow: 1. Start performance timer for monitoring 2. Extract and validate common form data 3. Create main playlist database record 4. Process detailed playlist structure 5. Log successful creation activity 6. Generate XML schedule document 7. Optional FTP upload (currently disabled) 8. Redirect to playlist detail view Performance Monitoring: - Tracks total processing time in milliseconds - Logs duration for performance analysis - Enables identification of bottlenecks Security Features: - User authentication required (enforced at view level) - Data validation through _extract_common_data - Audit logging for all playlist operations - CSRF protection for form submissions Example Usage: # Called from POST method when apply_btn is clicked return self._handle_apply_playlist(request, user) # Results in playlist creation and redirect to: # /playlists/detail/123/ (where 123 is the new playlist ID) draft_versionrFrIr)hourminutesecond microsecondtzinfo;rGF)rFversionbroadcast_date start_dateend_date zone_channelis_draftrTrHr/NTi)playlistr/ is_successful duration_ms)rcplaylists:playlist_detail id_playlist)timerSr7r3r"r,createreplacerPrutc_process_playlist_structure _log_activitygetattrrNr&generate_scheduleprintrid) r.r/r+ start_timedatarTrc generatorxml_playlist_resr1r1r2r8sRM      z)PlaylistCreateView._handle_apply_playlistcCs||}tdtjdS)aW Handle draft playlist creation and management for incremental playlist development. This method processes playlist creation in draft mode, allowing users to save incomplete or work-in-progress playlists for later modification and eventual activation. Draft playlists are not immediately broadcast-ready and require additional processing before they can be applied to live broadcast schedules. The draft functionality enables users to: - Save incomplete playlist configurations - Iteratively develop complex playlists over multiple sessions - Collaborate on playlist creation with approval workflows - Test playlist configurations before activation - Maintain version history of playlist development Currently, the core implementation is commented out pending infrastructure setup for draft storage and management. The method maintains the interface contract while preserving the implementation logic for future activation. Args: request (HttpRequest): Django HTTP request object containing: - POST data with form fields (same as apply playlist) - User session and authentication information - CSRF tokens for secure form submission - Optional existing draft ID for updates user (User): Django User model instance representing the authenticated user Used for draft ownership, permissions, and audit trail creation Returns: HttpResponseRedirect: Redirect to draft playlist management page showing: - Saved draft playlist information - Options for further editing - Convert to active playlist option - Draft version history URL pattern: "playlists:draft_playlist" with playlist ID parameter Raises: ValidationError: If _extract_common_data validation fails IntegrityError: If draft playlist creation violates database constraints AttributeError: If required model relationships are missing NotImplementedError: Currently raised due to commented implementation Database Operations (When Implemented): - Creates new Playlists record with is_draft=True - Sets draft version for tracking incremental changes - Processes playlist structure in draft mode - Maintains audit trail for draft operations Draft vs Apply Differences: - is_draft flag set to True - draft_version incremented for tracking - No XML generation for broadcast systems - No FTP upload to production servers - Relaxed validation for incomplete data - Additional save/resume functionality Processing Flow (When Active): 1. Extract and validate form data (same as apply) 2. Create draft playlist database record 3. Process playlist structure in draft mode 4. Skip XML generation and FTP deployment 5. Redirect to draft management interface Implementation Status: CURRENT: Core logic commented out pending infrastructure setup PLANNED: Full draft functionality with version control PRESERVED: Implementation logic maintained for easy activation Future Enhancements: - Draft-specific validation rules (more permissive) - Version comparison and diff functionality - Draft sharing and collaboration features - Automatic draft cleanup policies - Draft to production promotion workflows Security Considerations: - Draft ownership restricted to creating user - Same authentication requirements as apply playlist - Draft data isolated from production playlists - Audit logging for draft operations Example Usage: # Called from POST method when draft_btn is clicked return self._handle_draft_playlist(request, user) # Results in draft creation and redirect to: # /playlists/draft/123/ (where 123 is the draft playlist ID) Related Functionality: - _extract_common_data: Common validation logic - _process_playlist_structure: Structure generation - _handle_draft_xml_generation: Draft-specific XML processing - Draft management views: Edit, delete, promote drafts playlists:draft_playlistrg)rSrrcrr)r.r/r+rtr1r1r2r9sg 3z)PlaylistCreateView._handle_draft_playlistc Csd}|rt|dkr|Stt|D]}|jd|d}|sBq$|jd|d}|jd|d} ||| } t||| | d} | ||| ||t||}q$|S)a Process the complex nested structure of playlist components including windows, avails, and advertisements. This method orchestrates the creation of the complete playlist hierarchy by processing time windows and their associated advertisement availability slots. It handles the iterative creation of Windows records and delegates the processing of nested avails and advertisements to specialized handler methods. The method implements a hierarchical data processing pattern where: 1. Playlist contains multiple Windows 2. Each Window contains multiple Avails (advertisement slots) 3. Each Avail contains multiple Ads (specific advertisements) The processing maintains referential integrity across all levels and provides comprehensive validation to ensure data consistency and broadcast schedule accuracy. Args: request (HttpRequest): Django HTTP request object containing: - POST data with nested form arrays for windows/avails - Form fields indexed by window number (e.g., windowstart[0]) - User session and authentication information playlist (Playlists): Playlist model instance to associate windows with Must be a saved instance with valid primary key daydate (datetime): Formatted datetime object representing the broadcast date Used for scheduling calculations and time validation number_of_windows (str): String representation of total windows to process Must be convertible to positive integer Returns: int: Cumulative traffic counter value representing total processed advertisements Used for billing, reporting, and capacity planning purposes Incremented by each processed avail and advertisement Raises: ValueError: If number_of_windows cannot be converted to integer AttributeError: If playlist instance is invalid or unsaved IntegrityError: If window creation violates database constraints KeyError: If expected form fields are missing from request.POST Database Operations: - Creates Windows records linked to the playlist - Calculates and stores window duration based on start/end times - Delegates avail and advertisement creation to _process_avails - Maintains foreign key relationships across the hierarchy Form Data Structure Expected: - windowstart[0], windowstart[1], ... : Start times for each window - windowend[0], windowend[1], ... : End times for each window - numofavails[0], numofavails[1], ... : Avail counts per window - Additional nested data processed by _process_avails method Processing Flow: 1. Initialize traffic counter for advertisement tracking 2. Validate number_of_windows parameter 3. Iterate through each window index 4. Extract window-specific form data 5. Calculate window duration from start/end times 6. Create and save Windows database record 7. Process nested avails for current window 8. Accumulate traffic counter from avail processing 9. Return final traffic count Performance Considerations: - Processes windows sequentially to maintain order - Single database query per window creation - Bulk processing delegated to _process_avails method - Early termination for invalid window configurations Data Validation: - Validates number_of_windows is positive integer - Skips windows with missing or invalid avail counts - Ensures window start/end times are present - Validates window duration calculations Error Handling Strategy: - Graceful handling of missing form fields - Continues processing valid windows despite individual failures - Returns partial results when possible - Delegates detailed error handling to specialized methods Integration Points: - _calculate_window_duration: Computes time spans - _process_avails: Handles nested avail/ad processing - Windows model: Database representation of time windows - Form validation: Client-side and server-side validation Example Usage: traffic_count = self._process_playlist_structure( request=request, playlist=playlist_instance, daydate=datetime(2025, 7, 30), number_of_windows='3' ) Business Logic: - Each window represents a scheduled time slot for advertisements - Windows must have valid start/end times for broadcast scheduling - Traffic counter enables revenue tracking and capacity management - Window duration affects advertisement slot availability r numofavails[] windowstart[ windowend[)rc window_start window_endwindow_duration)rNranger7r3_calculate_window_durationr#save_process_avails) r.r/rcrIrHtraffici numofavailsr|r}r~windowr1r1r2rmDs4o   z.PlaylistCreateView._process_playlist_structurec Cst|D]|}d|d|d}|j|} | s0q|jd|d|d} t|| t|dd} | | r||| ||t| |}q|S)u Process advertisement availability slots (avails) within a specific broadcast window. This method handles the second level of the playlist hierarchy, processing avails which represent discrete advertisement opportunity slots within a broadcast window. Each avail defines a specific time slot where advertisements can be scheduled, and contains one or more individual advertisement records. The method iterates through all avails for a given window, creates the corresponding database records, and delegates the processing of nested advertisements to the specialized _process_ads method. It maintains the hierarchical relationship between windows and avails while accumulating traffic statistics. Avails serve as the fundamental scheduling unit for advertisement placement, providing the granular time slots that advertisers can purchase for their campaigns. Each avail is uniquely identified within its parent window and maintains precise timing information for broadcast coordination. Args: request (HttpRequest): Django HTTP request object containing: - Nested POST data with double-indexed form arrays - Form fields indexed by window and avail position - Advertisement data for each avail slot - User session and authentication information window (Windows): Window model instance that will contain the avails Must be a saved instance with valid primary key Represents the parent time window for these avails daydate (datetime): Formatted datetime object for the broadcast date Used for scheduling context and time calculations Provides date reference for avail timing window_index (int): Zero-based index of the current window being processed Used to access correct form fields in nested arrays Corresponds to window position in the playlist numofavails (int): Total number of avails to process for this window Must be a positive integer value Determines the iteration range for avail processing traffic (int): Current cumulative traffic counter from previous processing Represents total advertisement count processed so far Will be incremented by advertisements in processed avails Returns: int: Updated traffic counter including advertisements from all processed avails Accumulates advertisement counts from nested _process_ads calls Used for billing calculations and capacity reporting Maintains running total across all playlist components Raises: ValueError: If numofavails is not a valid positive integer AttributeError: If window instance is invalid or unsaved IntegrityError: If avail creation violates database constraints KeyError: If expected nested form fields are missing Database Operations: - Creates Avails records linked to the parent window - Sets avail position within window (availinwindow field) - Maintains foreign key relationship to Windows model - Delegates advertisement creation to _process_ads method Form Data Structure Expected: - availstart[window_index][avail_index]: Start time for each avail - numofads[window_index][avail_index]: Advertisement count per avail - Additional nested advertisement data processed by _process_ads Processing Flow: 1. Iterate through each avail index from 0 to numofavails-1 2. Extract avail start time from double-indexed form field 3. Validate avail data and skip if invalid 4. Extract advertisement count for current avail 5. Create and save Avails database record 6. Process nested advertisements for current avail 7. Accumulate traffic counter from advertisement processing 8. Continue to next avail or return final traffic count Data Validation: - Validates avail start time is present in form data - Skips avails with missing or invalid start times - Handles optional advertisement count gracefully - Ensures avail position numbering starts from 1 Performance Considerations: - Sequential processing maintains avail order within window - Single database query per avail creation - Efficient nested form field access using computed keys - Early continuation for invalid avail configurations Business Logic: - Avails represent purchasable advertisement time slots - Each avail has a unique position within its parent window - Avail timing must align with window boundaries - Traffic counter enables revenue and capacity tracking Integration Points: - _process_ads: Handles nested advertisement processing - Avails model: Database representation of advertisement slots - Windows model: Parent relationship for hierarchical structure - Form validation: Client-side and server-side data validation Example Usage: updated_traffic = self._process_avails( request=request, window=window_instance, daydate=datetime(2025, 7, 30), window_index=0, numofavails=5, traffic=current_traffic_count ) Avail Positioning: - availinwindow field uses 1-based indexing for business logic - Loop uses 0-based indexing for programming convenience - Position mapping: loop index j → avail position (j + 1) - Maintains consistent ordering for broadcast scheduling availstart[][ry numofads[rU)r avail_start availinwindow)rr7r3r$rLr _process_adsrN) r.r/rrI window_indexrrjZavail_start_keyav_start number_of_adsavailr1r1r2rs,z    z"PlaylistCreateView._process_availsc Csdt|D]V}d|d|d|d}|j|} | s6q|d7}t|| t|d|d} | q|S)u Process individual advertisement records within a specific advertisement availability slot. This method handles the deepest level of the playlist hierarchy, processing individual advertisements that will be scheduled within specific avail slots. Each advertisement represents a concrete commercial spot with specific content, duration, and positioning requirements for broadcast scheduling. The method creates AdspotsInAvail records that link specific advertisement content to precise time slots within the broadcast schedule. It maintains the complete hierarchical relationship from playlist → window → avail → advertisement and provides the granular scheduling data required for broadcast automation systems. This is the final stage of playlist structure processing, where abstract time slots are populated with actual advertisement content. The traffic counter is incremented for each successfully processed advertisement, providing accurate counts for billing, reporting, and compliance purposes. Args: request (HttpRequest): Django HTTP request object containing: - Triple-indexed POST data with nested form arrays - Advertisement IDs for each position within avails - Form fields indexed by window, avail, and ad position - User session and authentication information avail (Avails): Avail model instance that will contain the advertisements Must be a saved instance with valid primary key Represents the parent advertisement slot for these ads window_index (int): Zero-based index of the parent window being processed Used to access correct form fields in nested arrays Corresponds to window position in the playlist avail_index (int): Zero-based index of the parent avail being processed Used to access correct form fields in nested arrays Corresponds to avail position within the window number_of_ads (int): Total number of advertisements to process for this avail Must be a positive integer value Determines the iteration range for advertisement processing traffic (int): Current cumulative traffic counter from previous processing Represents total advertisement count processed so far Will be incremented by each advertisement processed here Returns: int: Updated traffic counter including all advertisements processed in this avail Incremented by one for each successfully processed advertisement Used for billing calculations, reporting, and compliance tracking Maintains accurate count across entire playlist hierarchy Raises: ValueError: If number_of_ads is not a valid positive integer AttributeError: If avail instance is invalid or unsaved IntegrityError: If advertisement creation violates database constraints KeyError: If expected triple-indexed form fields are missing Database Operations: - Creates AdspotsInAvail records linking advertisements to avail slots - Sets advertisement position within avail (positioninavail field) - Assigns unique traffic ID for each advertisement record - Maintains foreign key relationship to Avails model Form Data Structure Expected: - ad[window_index][avail_index][ad_index]: Advertisement ID for each position - Triple indexing enables precise advertisement placement - Form structure mirrors the complete playlist hierarchy Processing Flow: 1. Iterate through each advertisement index from 0 to number_of_ads-1 2. Extract advertisement ID from triple-indexed form field 3. Validate advertisement data and skip if invalid 4. Increment traffic counter for billing and reporting 5. Create and save AdspotsInAvail database record 6. Continue to next advertisement or return final traffic count Traffic Counter Logic: - Incremented once per successfully processed advertisement - Provides accurate count for revenue calculation - Enables compliance reporting and audit trails - Supports capacity planning and inventory management Advertisement Positioning: - positioninavail field uses 1-based indexing for business logic - Loop uses 0-based indexing for programming convenience - Position mapping: loop index k → advertisement position (k + 1) - Maintains precise ordering for broadcast playback sequence Data Validation: - Validates advertisement ID is present in form data - Skips advertisements with missing or invalid IDs - Handles sparse advertisement configurations gracefully - Ensures traffic counter accuracy despite validation failures Performance Considerations: - Sequential processing maintains advertisement order within avail - Single database query per advertisement creation - Efficient triple-indexed form field access using computed keys - Early continuation for invalid advertisement configurations Business Logic: - Each advertisement represents billable inventory - Advertisement positioning affects broadcast scheduling - Traffic IDs enable precise advertisement tracking - Position within avail determines playback sequence Integration Points: - AdspotsInAvail model: Database representation of scheduled advertisements - Avails model: Parent relationship for hierarchical structure - Advertisement inventory system: Source of advertisement content - Billing system: Uses traffic counter for revenue calculation Example Usage: final_traffic = self._process_ads( request=request, avail=avail_instance, window_index=0, avail_index=2, number_of_ads=3, traffic=current_traffic_count ) Broadcast Integration: - Created records drive automated broadcast systems - Traffic IDs enable real-time playback tracking - Position data ensures correct advertisement sequencing - Timing data coordinates with broadcast schedules ad[rryrU)r adspot_idpositioninavail trafficid)rr7r3r%rLr) r.r/rrZ avail_indexrrkZad_keyadspot ads_in_availr1r1r2rs     zPlaylistCreateView._process_adscCsPtjtjtj|d}tjtjtj|d}||}|S)a Calculate the duration of a broadcast window for scheduling and billing purposes. This method computes the time span between window start and end times, handling time format parsing and duration calculation for broadcast scheduling systems. The calculated duration is used for advertisement slot allocation, billing calculations, and broadcast automation timing requirements. The method currently contains placeholder implementation with the core logic commented out pending finalization of duration format requirements and edge case handling strategies. The preserved implementation shows the intended calculation approach using datetime arithmetic. Key considerations for duration calculation: - Handles standard HH:MM time format input - Manages day boundary crossings (e.g., 23:30 to 01:30) - Provides duration in format suitable for broadcast systems - Validates input times and handles parsing errors - Supports both same-day and cross-midnight windows Args: window_start (str): Window start time in HH:MM format Examples: "09:30", "14:15", "23:45" Must be valid 24-hour time format Used as the beginning of the broadcast window window_end (str): Window end time in HH:MM format Examples: "10:00", "14:45", "00:15" Must be valid 24-hour time format Used as the conclusion of the broadcast window Returns: str: Formatted duration string suitable for broadcast systems Format depends on business requirements (pending implementation) Examples might include: "00:30:00", "1.5 hours", "90 minutes" Currently returns None due to commented implementation Raises: ValueError: If time strings cannot be parsed in HH:MM format TypeError: If input parameters are not strings AttributeError: If datetime operations fail due to invalid data Implementation Status: CURRENT: Core logic commented out pending format specification PLANNED: Full duration calculation with multiple output formats PRESERVED: Implementation approach maintained for easy activation Time Handling Considerations: - Same-day windows: start < end (e.g., 09:00 to 17:00) - Cross-midnight windows: start > end (e.g., 23:00 to 01:00) - Zero-duration windows: start == end (special case handling) - Invalid ranges: end before start on same day Business Logic Applications: - Advertisement slot duration for billing - Broadcast schedule timing validation - Capacity planning and inventory management - Automated playlist generation timing - Compliance reporting for broadcast regulations Example Usage: duration = self._calculate_window_duration("09:30", "10:15") # Expected result: "00:45:00" or equivalent format duration = self._calculate_window_duration("23:30", "01:15") # Expected result: "01:45:00" (cross-midnight calculation) Future Enhancements: - Multiple output format support (HH:MM:SS, minutes, decimal hours) - Timezone handling for multi-region broadcasts - Business day vs calendar day duration options - Duration validation against minimum/maximum window constraints - Integration with broadcast system time standards Integration Points: - Windows model: Duration field for database storage - Broadcast scheduling: Timing coordination - Billing system: Duration-based pricing calculations - Playlist validation: Window timing consistency checks %H:%M)rPcombinedatetodayrQri)r.r|r}durationr1r1r2rsW z-PlaylistCreateView._calculate_window_durationcCsdS)a Handle automated FTP upload of generated XML playlist files to broadcast servers. This method manages the deployment of generated playlist XML files to remote broadcast automation systems via FTP protocol. It provides the critical link between playlist creation and broadcast system integration, ensuring that created playlists are automatically deployed to the appropriate servers for immediate broadcast availability. The method implements a complete FTP deployment workflow including configuration retrieval, connection establishment, file transfer, and error handling. It supports multiple broadcast environments and provides robust error recovery for network connectivity issues. Currently, the implementation is disabled pending infrastructure configuration and security review. The preserved logic demonstrates the intended workflow and can be activated when deployment requirements are finalized. Args: xml_playlist_res (dict): XML generation result containing: - 'status' (bool): Success status of XML generation - 'file' (str): Path to generated XML file - 'filename' (str): Name of the XML file - 'errors' (list): Any generation errors - 'metadata' (dict): Additional file information playlist (Playlists): Playlist model instance for configuration context Used to determine target FTP server and deployment path Contains channel and zone information for routing Returns: None: Method performs side effects (file upload) without return value Success/failure communicated through logging and exception handling Raises: ConnectionError: If FTP server connection cannot be established AuthenticationError: If FTP credentials are invalid or expired FileNotFoundError: If generated XML file is missing or inaccessible PermissionError: If insufficient permissions for file upload TimeoutError: If FTP transfer exceeds configured timeout limits Implementation Status: CURRENT: Implementation disabled with pass statement PLANNED: Full FTP deployment with error handling and logging PRESERVED: Core logic maintained for easy activation SECURITY: Pending security review for credential management FTP Deployment Workflow (When Active): 1. Validate XML generation was successful 2. Retrieve FTP configuration for target playlist 3. Initialize FTP connector with server credentials 4. Establish secure connection to broadcast server 5. Upload XML file to designated remote path 6. Verify successful transfer and file integrity 7. Log deployment status for audit trail 8. Clean up temporary files and connections Configuration Requirements: - FTP server hostnames and ports - Authentication credentials (username/password or key-based) - Remote directory paths for different channels/zones - Transfer mode settings (binary/ASCII) - Timeout and retry configurations - SSL/TLS encryption settings for secure transfers Security Considerations: - Credential storage and encryption - Secure FTP (SFTP) or FTP over SSL/TLS - Network access control and firewall rules - File permission validation on remote servers - Audit logging for compliance and monitoring Error Handling Strategy: - Retry logic for temporary network failures - Fallback servers for high availability - Graceful degradation when FTP is unavailable - Detailed error logging for troubleshooting - User notification for critical deployment failures Performance Optimization: - Connection pooling for multiple uploads - Compression for large XML files - Parallel uploads to multiple servers - Transfer progress monitoring and reporting - Bandwidth throttling for network management Integration Points: - _get_ftp_config: Retrieves server-specific configuration - FTPConnector: Handles low-level FTP operations - Logging system: Records deployment activities - Monitoring system: Tracks deployment success rates - Alert system: Notifies on deployment failures Example Usage (When Implemented): xml_result = generator.generate_schedule(playlist) self._handle_ftp_upload(xml_result, playlist) # Results in XML file deployed to: # ftp://broadcast-server/playlists/channel_123/playlist_456.xml Business Impact: - Enables automated broadcast deployment - Reduces manual intervention and errors - Supports real-time playlist updates - Ensures consistent deployment processes - Facilitates compliance with broadcast schedules Monitoring and Analytics: - Upload success/failure rates - Transfer duration and performance metrics - Server availability and connectivity status - File integrity verification results - Deployment frequency and patterns Nr1)r.rvrcr1r1r2_handle_ftp_uploadsyz%PlaylistCreateView._handle_ftp_uploadNTc Cs6ddlm}m}z|jjdd}Wn|jk r<d}YnXd|jrN|jjnd} |jrr| d|j d 7} t |j |jr|jj nd|jr|jjnd|jr|j nd|jr|j nd|jr|j nd|jr|jjnd|j|j|jd } |j|jd d |jr|jjnd d|t||jdd| ddS)a= Log comprehensive playlist creation activity for audit trail, compliance, and monitoring. This method creates detailed audit records for all playlist operations, providing complete traceability for compliance, debugging, and business intelligence purposes. It captures user actions, system performance, and contextual metadata to enable comprehensive analysis of playlist creation patterns and system behavior. The logging system integrates with the centralized activity tracking framework to maintain consistent audit trails across all system operations. This supports regulatory compliance, security monitoring, and operational analytics for broadcast scheduling systems. The method handles both successful and failed operations, capturing appropriate context and error information to support troubleshooting and system optimization. It also records performance metrics to enable capacity planning and performance monitoring across the playlist creation workflow. Args: playlist (Playlists): The Playlist model instance that was created or attempted Contains all playlist metadata and relationships Used to extract contextual information for logging request (HttpRequest, optional): Django request object containing: - User authentication information - Client IP address and user agent - Session data and request metadata - HTTP headers for security analysis is_successful (bool, optional): Success status of the playlist operation Defaults to True for successful operations Used to categorize and filter activity logs error_message (str, optional): Detailed error message for failed operations Provides debugging context for failures Stored in activity metadata for analysis duration_ms (int, optional): Processing duration in milliseconds Used for performance monitoring and optimization Enables identification of slow operations Returns: None: Method performs logging side effects without return value Success/failure communicated through logging system Raises: AttributeError: If playlist instance lacks required attributes ImportError: If Activity or ActivityCategory models are unavailable DatabaseError: If activity logging fails due to database issues Database Operations: - Retrieves or handles missing ActivityCategory for 'PLAYLIST' - Creates comprehensive Activity record with full metadata - Stores user information, timing data, and system context - Maintains audit trail for compliance and security monitoring Metadata Structure: - playlist_id: Unique identifier for created playlist - channel_id: Channel identifier for scheduling context - channel_name: Human-readable channel name - broadcast_date: Scheduled broadcast date in ISO format - start_date: Window start time in ISO format - end_date: Window end time in ISO format - zone_channel: Geographic or programming zone identifier - version: Playlist version for change tracking - is_draft: Draft status for workflow management - draft_version: Draft iteration for version control Security and Compliance: - Records user identity and authentication status - Captures client IP address for security monitoring - Logs user agent for client analysis and security - Maintains tamper-evident audit trails - Supports regulatory compliance requirements Performance Monitoring: - Records operation duration for optimization - Enables identification of performance bottlenecks - Supports capacity planning and resource allocation - Provides data for system performance analysis Example Usage: # Successful playlist creation self._log_activity( playlist=created_playlist, request=request, is_successful=True, duration_ms=1250 ) # Failed playlist creation self._log_activity( playlist=partial_playlist, request=request, is_successful=False, error_message="Invalid channel configuration", duration_ms=450 ) r)ActivityActivityCategoryZPLAYLIST)codeNzCreated playlist for zUnknown Channelz scheduled for %Y-%m-%d) playlist_idr< channel_namer^r_r`rar]rbrTCREATEUser Systemz performed create_playlistHTTP_USER_AGENTr@)r+action descriptionr/ ip_address user_agentmetadata)apps.activities.modelsrrr,r3rJrFrr^strftimerLrrr> isoformatr_r`raregionr]rbrT log_activityr+emailrMETA) r.rcr/rd error_messagererrcategoryrrr1r1r2rns8g   z PlaylistCreateView._log_activitycCsdS)a Generate XML preview files for draft playlists without production deployment. This method creates XML representations of draft playlists for preview, validation, and testing purposes without deploying to production broadcast systems. It enables users to review the generated schedule format and validate playlist structure before committing to live broadcast deployment. Draft XML generation serves multiple purposes: - Preview generation for user review and approval workflows - Format validation before production deployment - Testing and development of playlist structures - Compliance verification without affecting live broadcasts - Template generation for repeated playlist patterns The method currently contains placeholder implementation with core logic commented out pending infrastructure setup for draft XML processing and storage systems. The preserved logic demonstrates the intended workflow for generating and managing draft XML files. Args: data (dict): Validated playlist data dictionary containing: - 'daydate': Formatted broadcast date for scheduling - 'channel_id': Channel identifier for routing - 'channel_zone': Zone configuration for regional settings - Additional scheduling and configuration parameters playlist (Playlists): Draft playlist model instance containing: - Playlist structure and timing information - Channel and zone relationships - Draft-specific metadata and version information Returns: None: Method performs XML generation side effects without return value Generated files managed through file system or storage service Success/failure communicated through logging and exception handling Raises: AttributeError: If required data fields are missing or invalid FileNotFoundError: If XML generation templates are unavailable PermissionError: If insufficient permissions for file creation ValidationError: If playlist data fails XML schema validation Implementation Status: CURRENT: Core logic commented out pending infrastructure setup PLANNED: Full draft XML generation with preview capabilities PRESERVED: Implementation approach maintained for easy activation INTEGRATION: Pending storage and preview system configuration Draft XML Workflow (When Active): 1. Extract playlist scheduling parameters from data dictionary 2. Initialize XML generator with draft-specific configuration 3. Generate XML content from playlist structure and timing 4. Validate generated XML against broadcast system schemas 5. Store XML file in draft storage location for preview 6. Create preview URLs or file references for user access 7. Log generation activity for audit and monitoring XML Generation Parameters: - daydate: Target broadcast date for scheduling context - channel_id: Channel identifier for content routing - zone_channel_id: Zone identifier for regional configuration - version: Draft version identifier for tracking Storage Considerations: - Draft XML files stored separately from production files - Temporary storage with configurable retention policies - Access control for draft file security and privacy - Version tracking for iterative draft development - Cleanup policies for abandoned drafts Preview Integration: - Web interface for XML preview and validation - Download capabilities for offline review - Diff comparison with previous draft versions - Integration with approval and collaboration workflows - Format validation and compliance checking Business Applications: - Client approval processes for broadcast schedules - Compliance review before production deployment - Testing new playlist configurations safely - Training and education on playlist structures - Template development for repeated patterns Example Usage (When Implemented): validated_data = self._extract_common_data(request) self._handle_draft_xml_generation(validated_data, draft_playlist) # Results in draft XML file created at: # /drafts/xml/channel_123/draft_playlist_456_v1.xml Integration Points: - GenerateXMLfromDatabase: Core XML generation functionality - Draft storage system: File management and retention - Preview interface: User access to generated XML - Validation system: Schema and compliance checking - Logging system: Activity tracking and monitoring Nr1)r.rtrcr1r1r2_handle_draft_xml_generation<sjz/PlaylistCreateView._handle_draft_xml_generation)NTNN)__name__ __module__ __qualname____doc__r3r;rSr8r9rmrrrrrnrr1r1r1r2r'$s*oVg"7MCAs )r'c@s8eZdZdZddZddZddZdd Zd d Zd S) PlaylistDetailViewzB Detailed view for individual playlist with related data. cCsrzHtjddj||jd}|||||||d}t|d|WStj k rlt|dddYSXd S) z Display detailed playlist information. Args: request: Django HTTP request object id_playlist: Playlist ID Returns: HttpResponse: Rendered template rFrarrchannel__id_user)rcwindowsstatstimelinezplaylists/detail.htmlzplaylists/not_found.htmli)statusN) r"r,select_relatedr3r+_get_playlist_windows_get_detailed_stats_get_playlist_timelinerrJ)r.r/rhrcr0r1r1r2r3s   zPlaylistDetailView.getc Csg}|jdD]p}g}|jdD]F}g}|jdD]}||j|j|jdqD|||dq,|||dq|S)z Get organized window data for the playlist. Args: playlist: Playlist model instance Returns: list: Organized window data r|rr)rposition traffic_id)rads)ravails) rallorder_byradspots_in_availappendrrr)r.rcZ windows_datarZ avails_datarZads_dataadr1r1r2rs(    z(PlaylistDetailView._get_playlist_windowscCs^|j}tdd|D}tdd|D}||||dkrNt||dnd||dS)z Get detailed statistics for the playlist. Args: playlist: Playlist model instance Returns: dict: Detailed statistics css|]}|jVqdSN)rcount).0rr1r1r2 sz9PlaylistDetailView._get_detailed_stats..css(|] }|jD]}|jVqqdSr)rrrr)rrrr1r1r2rs r)Z total_windows total_avails total_adsZavg_ads_per_availZ duration_info)rrsumrround_calculate_total_duration)r.rcrrrr1r1r2r s z&PlaylistDetailView._get_detailed_statscCsLd}|D]}|jr||j7}q|d}t|dt|ddt|ddS)z Calculate total duration information. Args: windows: Window queryset Returns: dict: Duration information r<r) total_minutesZ total_hours total_seconds)r~rr)r.rrrrr1r1r2r's  z,PlaylistDetailView._calculate_total_durationc Csddlm}m}m}ddlm}d|jdd|jddg}|j d D]}t |j |rt |d | }|||j } || r|| } n|j } || r|| } |d | d d |jddqLt|dddS)z Get timeline information for the playlist. Args: playlist: Playlist model instance Returns: list: Timeline events r)rPrrirzPlaylist CreatedcreationzPlaylist version z created)eventrPtyperr|rzWindow Scheduledrz Window with z availscSs|dS)NrPr1)xr1r1r2nz;PlaylistDetailView._get_playlist_timeline..)key)rPrri django.utilsr created_atr]rrr isinstancer|rorris_naive make_awarerrrsorted) r.rcrPrrirrr playlist_dateZwindow_datetimer1r1r2r@s0          z)PlaylistDetailView._get_playlist_timelineN) rrrrr3rrrrr1r1r1r2rs )%rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8S)9PlaylistListViewz Class-based view for listing and filtering playlists using base View class. Supports search, filtering, sorting, and pagination with full control. cCs|jddkr||S||}t|||}|jdd}z||}Wn<tk rn|d}Yn t k r||j }YnX| |||}t |d|S)z Handle GET requests for playlist listing. Args: request: Django HTTP request object Returns: HttpResponse or JsonResponse for AJAX requests X-Requested-WithXMLHttpRequestpagerUzplaylists/list.html) headersr3_handle_ajax_request_get_filtered_querysetr_get_items_per_pageGETget_pagerr num_pages_build_contextr)r.r/queryset paginator page_numberpage_objr0r1r1r2r3ws   zPlaylistListView.getcCst|jd}|jd}|s*tdddS|dkr>|||S|dkrR|||S|dkrf|||Stdd dS) z Handle POST requests for bulk operations. Args: request: Django HTTP request object Returns: JsonResponse with operation results r playlist_idsFzNo playlists selected.successmessageZ bulk_deleteZ bulk_exportZbulk_status_changezInvalid action.)r7r3getlistr_handle_bulk_delete_handle_bulk_export_handle_bulk_status_change)r.r/rrr1r1r2r;s"     zPlaylistListView.postcCs|j}tjdddddjtdddtdddtddddj|d }|||}| ||}| ||}| ||}| ||}| ||}|S) z Get filtered and sorted queryset based on request parameters. Args: request: Django HTTP request object Returns: QuerySet: Filtered playlist queryset rFrarZwindows__avails!windows__avails__adspots_in_availT)distinct) window_countrrr)r+r"r,rprefetch_relatedannotater r-_apply_search_filter_apply_channel_filter_apply_date_filter_apply_status_filter_apply_zone_filter_apply_sorting)r.r/r+rr1r1r2rs,           z'PlaylistListView._get_filtered_querysetcCsR|jdd}|rN|t|dt|dBt|dBt|dBt|dB}|S)z Apply search filter based on search query. Args: request: Django HTTP request object queryset: Base queryset Returns: QuerySet: Filtered queryset searchr@)Z channel__channel_name__icontains)Z$zone_channel__networkname__icontains)Zzone_channel__region__icontains)Zbroadcast_date__icontains)Zversion__icontains)rr3rMr-r )r.r/r search_queryr1r1r2r s z%PlaylistListView._apply_search_filterc CsN|jd}|rJ|dkrJzt|}|j|d}Wnttfk rHYnX|S)z Apply channel filter. Args: request: Django HTTP request object queryset: Base queryset Returns: QuerySet: Filtered queryset rFr)Zchannel__id_channelrr3rNr-rO TypeError)r.r/rr<r1r1r2r s  z&PlaylistListView._apply_channel_filtercCs*|jd}|jd}|jd}|rt}|dkrN|j|d}nX|dkrv|tjdd}|j|d}n0|d kr|tj|d}|j|d }n|d kr|tj|d d}|tjd d} |j|| d}n|dkr|j dd} |j| d }n|dkr|j dkr4|j |j dddd} n|j |j ddd} | j dkrx| j | j ddddtjdd} n | j | j dddtjdd} |j| | d}|rz"tj |d} |j| d }Wnt k rYnX|r&z"tj |d}|j|d}Wnt k r$YnX|S)z Apply date range filter with predefined and custom ranges. Args: request: Django HTTP request object queryset: Base queryset Returns: QuerySet: Filtered queryset date_fromdate_to date_rangerr^ yesterdayrUdays this_week)broadcast_date__gteZ last_week)rbroadcast_date__lte this_monthrD last_month )yearmonthrD)r$rDr)r)rr3rnowrr-rP timedeltaweekdayrkr$r#rQrO)r.r/rrrrrr week_startweek_end month_startr! month_endZdate_from_parsedZdate_to_parsedr1r1r2r  s^         $ z#PlaylistListView._apply_date_filtercCs:|jd}|dkr"|jdd}n|dkr6|jdd}|S)z Apply status filter (draft/published). Args: request: Django HTTP request object queryset: Base queryset Returns: QuerySet: Filtered queryset rdraft1rb published0)rr3r-)r.r/rrr1r1r2r T s  z%PlaylistListView._apply_status_filterc CsN|jd}|rJ|dkrJzt|}|j|d}Wnttfk rHYnX|S)z Apply zone/region filter. Args: request: Django HTTP request object queryset: Base queryset Returns: QuerySet: Filtered queryset zoner)Zzone_channel__id_zone_channelr)r.r/rzone_idr1r1r2r h s  z#PlaylistListView._apply_zone_filtercCsT|jdd}dddddddd d d d d ddddg}||krF||}n |d}|S)z Apply sorting based on sort parameter. Args: request: Django HTTP request object queryset: Base queryset Returns: QuerySet: Sorted queryset sort_by -created_atrr^-broadcast_datechannel__channel_name-channel__channel_namer]z-versionr -window_countr -total_adsr -total_availsrb -is_draft)rr3r)r.r/rr3valid_sort_fieldsr1r1r2r~ s,    zPlaylistListView._apply_sortingc CsDz$t|jdd}tdt|dWSttfk r>YdSXdS)z Get number of items per page from request or default. Args: request: Django HTTP request object Returns: int: Items per page per_page dN)rNrr3maxminrOr)r.r/r=r1r1r2r s z$PlaylistListView._get_items_per_pagecCsX|j}|j|||jdk|||||||||||j |j |jd }|S)a Build template context with all necessary data. Args: request: Django HTTP request object page_obj: Paginated page object paginator: Paginator instance Returns: dict: Template context rU) playlistsrr is_paginatedr*zones filter_params sort_optionsrr total_results current_page total_pages) r+ object_listr_get_user_channels_get_available_zones_get_current_filters_get_sort_options_get_playlist_stats_get_date_rangernumber)r.r/rrr+r0r1r1r2r s zPlaylistListView._build_contextcCstjj|ddS)z Get channels available to the current user. Args: user: Current user object Returns: QuerySet: User's channels r(r)r r,r-rr.r+r1r1r2rL s z#PlaylistListView._get_user_channelscCstjj|dddS)z Get zones available to the current user. Args: user: Current user object Returns: QuerySet: Available zones )id_channel__id_user networknamer)r!r,r-rrrSr1r1r2rM s  z%PlaylistListView._get_available_zonesc Csr|jdd|jdd|jdd|jdd|jdd|jdd|jd d|jd d |jd d d S)z Get current filter parameters for template. Args: request: Django HTTP request object Returns: dict: Current filter values rr@rFrr1rrrrr3r4r=20) rrFr1rrrrr3r=)rr3)r.r/r1r1r2rN s         z%PlaylistListView._get_current_filtersc Cs\ddddddddddd dd d dd d ddddddddddddddddg S)zv Get available sorting options. Returns: list: Sort options for template r4z Newest First)valuelabelrz Oldest Firstr5zBroadcast Date (Newest)r^zBroadcast Date (Oldest)r6zChannel Name (A-Z)r7zChannel Name (Z-A)r8z Most Windowsr9zMost Adsr:z Most AvailsrbzPublished Firstr;z Drafts Firstr1)r.r1r1r2rO sz"PlaylistListView._get_sort_optionsc Cstjj|d}t}|tjdd}||jdd|jdd|j|d|jttjddd|j|dd |j|d d S) z Get playlist statistics for dashboard. Args: user: Current user object Returns: dict: Playlist statistics rrrr-r.r0r)created_at__gte)Zbroadcast_date__gtrb)broadcast_date__lt)total_playlistsdraft_playlistspublished_playlistsZtodays_playlistsZrecent_playlistsZupcoming_playlistsZpast_playlists) r"r,r-rr%rrPr&r)r.r+ base_querysetrweek_agor1r1r2rP s$  z$PlaylistListView._get_playlist_statsc CsZt}||tjdd|tj|d|jdd|tjdd|tjdddS)zz Get date range information for filtering. Returns: dict: Date range options rUrr im)rrr(r*min_datemax_date)rr%rrPr&r'rk)r.rr1r1r2rQ; s  z PlaylistListView._get_date_rangecCs^|jd}|dkr||S|dkr0||S|dkrB||S|dkrT||S||S)z Handle AJAX requests for dynamic updates. Args: request: Django HTTP request object Returns: JsonResponse: JSON response with data r get_zones quick_stats export_data load_more)rr3_get_zones_for_channel_ajax_get_quick_stats_ajax_export_playlist_data_ajax_load_more_playlists_ajax_get_filtered_playlists_ajax)r.r/rr1r1r2rM s     z%PlaylistListView._handle_ajax_requestc Cs~|jd}|stdddSz4t|}tjj|dddd}td t|d WSt t fk rxtdd dYSXd S) z Get zones for a specific channel via AJAX. Args: request: Django HTTP request object Returns: JsonResponse: JSON response with zone data r<FzChannel ID requiredrr:) id_channel_idrBrUrT)rrEzInvalid channel IDN) rr3rrNr!r,r-valueslistrOr)r.r/r<rEr1r1r2rfe s$  z,PlaylistListView._get_zones_for_channel_ajaxcCs|j}||}td|dS)z Get quick statistics via AJAX. Args: request: Django HTTP request object Returns: JsonResponse: JSON response with statistics T)rr)r+rPr)r.r/r+rr1r1r2rg s  z&PlaylistListView._get_quick_stats_ajaxcCs,||}tdd|dd|dS)z Export playlist data via AJAX. Args: request: Django HTTP request object Returns: JsonResponse: JSON response with export status TExport prepared for playlists#)rr download_urlr)rrr)r.r/rr1r1r2rh s z+PlaylistListView._export_playlist_data_ajaxc Cs"|jdd}||}||}t||}z||}Wn&ttfk r`tdddYSXg}|j D]}| |j |j j |jjd|jj|jd|j|jdkt|d d t|d d t|d d |jd d|j dd|j dd qltd|||r|nd|j|jdS)z Load more playlists for infinite scroll. Args: request: Django HTTP request object Returns: JsonResponse: JSON response with more playlists rrUFz Invalid pagerk - rr-rrrr%Y-%m-%d %H:%Mz /playlists//z/edit/) rrrr1r^r]rbrrr creation_dateZ detail_urlZedit_urlTN)rrChas_next next_pagerJrI)rr3rrrrrrrrKrrhr>rrBrUrr^rr]rbrorrwnext_page_numberrrR) r.r/rr=rrrplaylists_datarcr1r1r2ri s@            z*PlaylistListView._load_more_playlists_ajaxcCs||}tt|jddd}|d|}g}|D]b}||j|jj|j j d|j j |j d|j|jdkt|dd t|d d |j d d q6td ||t|dS)z Get filtered playlists for AJAX requests. Args: request: Django HTTP request object Returns: JsonResponse: JSON response with filtered playlists limit2r@Nrsrr-rrrrt) rrrr1r^r]rbrrrvT)rrC total_countZdisplayed_count)rrBrNrr3rrhr>rrBrUrr^rr]rbrorrrlen)r.r/rr{rCrzrcr1r1r2rj s,      z-PlaylistListView._get_filtered_playlists_ajaxc Cs6z|j}d}g}|D]}zXtjj||d}tj}|j|kr\|jdkr\| d|Wq| ||d7}Wqtj k r| d|dYqt k r} z| d|d t | W5d } ~ XYqXqtd ||d |d dWSt k r0} z tddt | dWYSd } ~ XYnXd S)a Handle bulk deletion of playlists. Args: request: Django HTTP request object playlist_ids: List of playlist IDs to delete Returns: JsonResponse: Result of bulk operation rrhrTr0zCannot delete active playlist rUz Playlist z not foundzError deleting playlist z: NTzSuccessfully deleted rp)r deleted_counterrorsrFzBulk delete failed: r)r+r"r,r3rPrrr^rbr_delete_playlist_cascaderJrKrLr) r.r/rr+rrrrcrrRr1r1r2r s>    .  z$PlaylistListView._handle_bulk_deletecCstddt|dddS)a Handle bulk export of playlists. Args: request: Django HTTP request object playlist_ids: List of playlist IDs to export Returns: JsonResponse: Result of bulk operation Trorprq)rrrr)rr~)r.r/rr1r1r2r0 s z$PlaylistListView._handle_bulk_exportc Cs|jd}|dkr"tdddSzh|j}d}tjj||d}|D]}||_||d7}qB|d krjd nd }td |d |d|dWSt k r} z tddt | dWYSd} ~ XYnXdS)a Handle bulk status change (draft/published). Args: request: Django HTTP request object playlist_ids: List of playlist IDs to update Returns: JsonResponse: Result of bulk operation new_status)r0r-FzInvalid status valuerr)id_playlist__inrTrUr-r,r/TzSuccessfully updated z playlists to )r updated_countrzBulk status update failed: N) r7r3rr+r"r,r-rbrrKrL) r.r/rrr+rrCrcZ status_namerRr1r1r2rB s8    z+PlaylistListView._handle_bulk_status_changecCsV|jD]0}|jD]}|jq|jq |j|dSz Delete playlist and all related objects in proper order. Args: playlist: Playlist model instance N windows_setr avails_setadspotsinAvail_setdeleter.rcrrr1r1r2rq s z)PlaylistListView._delete_playlist_cascadeN)rrrrr3r;rr r r r r rrrrLrMrNrOrPrQrrfrgrhrirjrrrrr1r1r1r2rqs8!(G '  /%3/rc@sheZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZdS)PlaylistEditViewz Class-based view for editing playlists with form handling. Combines the functionality of the original new_playlist view but for editing. cCsttjddd||jd}||sBt|dt d|dSt jj |jd}t jj |j d }||}||d |i|d d }t|d |S)a Handle GET requests - render the edit form with existing data. Args: request: Django HTTP request object playlist_id: ID of the playlist to edit Returns: Rendered edit form template rFrarrThis playlist cannot be edited.rfrgr(r=r*T)rc playlist_datartrEZis_editzplaylists/edit.html)rr"r,rrr+_can_edit_playlistrr:rr r-r!rF_structure_playlist_datar)r.r/rrcr*rErr0r1r1r2r3 s.     zPlaylistEditView.getcCsttjdd||jd}||srarBr^rr]rbrrrrrr|r}rrrrrrrr)r.rcrtrZ window_datarZ avail_datarr1r1r2r s:       z)PlaylistEditView._structure_playlist_datac Cszht>||||||||t|}||j|W5QRXt |dt d|j dWSt k r}z,t |dt|t d|j dWYSd}~XYnXdS)z Handle playlist update (apply changes). Args: request: Django HTTP request object playlist: Playlist model instance Returns: HttpResponse redirect zPlaylist updated successfully.rfrgzError updating playlist: rrN)ratomic_update_playlist_basic_info_clear_playlist_structure_recreate_playlist_structuregenerateSchedule_log_update_activityr+rrrrrrKr:rL)r.r/rcrvrRr1r1r2r s      z(PlaylistEditView._handle_update_playlistc Csz|tXd|_tt|jd|_|||||| ||| | |j |W5QRXt |dtdWStk r}z,t |dt|td|jdWYSd}~XYnXdS) z Handle saving playlist as draft. Args: request: Django HTTP request object playlist: Playlist model instance Returns: HttpResponse redirect r-rUzPlaylist saved as draft.rwzError saving draft: rrN)rrrbrLrNr]rTrrrr_log_draft_activityr+rrrrKr:rh)r.r/rcrRr1r1r2r= s       z&PlaylistEditView._handle_save_as_draftcCs|jd}|rJtjt|d}|d}||_|d|_|d|_|jdd }|rxt j j|j |d}||_ |d S) z Update basic playlist information. Args: request: Django HTTP request object playlist: Playlist model instance rDrErT00:01:00+00:00T23:59:00+00:00r?r@rAN)r7r3rPrQrLrr^r_r`rMr!r,rFrBr)r.r/rcrIr?rGr1r1r2ra s    z,PlaylistEditView._update_playlist_basic_infocCsN|jD]0}|jD]}|jq|jq |jdS)z Clear existing playlist structure (windows, avails, ads). Args: playlist: Playlist model instance N)rrrrrrr1r1r2r~ s z*PlaylistEditView._clear_playlist_structurec Cs&|jd}|jd}d}|r"t|dkr"tt|D]}|jd|dr<|jd|d}|jd|d}|d|d}|jd |d} |d| d} d } tj| | tj|| } tjt| d } | d } t ||| | d } | tt|D] } |jd|d| dr|jd|d| d}|d|d}|jd|d| d}t | |t| dtj d}| tt|D]p}|jd|d| d|dr|jd|d| d|d}|d7}t ||t|d|d}| qqqrrr.r+rcrr1r1r2r s z%PlaylistEditView._log_update_activitycCsDz2tdtjd|jd|jdd}|Wn YnXdS)z Log playlist draft save activity. Args: user: User who saved the draft playlist: Draft playlist instance zSave Playlist Draftrz saved playlist ID: z as draftrN)rrPr%rrhrrr1r1r2r s z$PlaylistEditView._log_draft_activityN)rrrrr3r;rrrrrrrrrr1r1r1r2r s,!1#$Erc@sHeZdZdZddZddZddZdd Zd d Zd d Z ddZ dS)PlaylistDeleteViewz~ Class-based view for deleting playlists with proper authorization. Supports both AJAX and regular HTTP requests. c Cs*zttjd||jd}||s2||dWS|j|jj |j |j d}t ||W5QRX||j||jddkrtdd|dd d WSt|d|dd td WSWn^tjk r||d YStk r$}z||d t|WYSd}~XYnXdS)z Handle playlist deletion. Args: request: Django HTTP request object playlist_id: ID of the playlist to delete Returns: JsonResponse or HttpResponse redirect rFrzMCannot delete this playlist. It may be currently active or have dependencies.)rrrFr^r]rrTz Playlist for z deleted successfully.rr6zPlaylist not found.zError deleting playlist: N)rr"r,rr+_can_delete_playlist_handle_delete_errorrhr>rr^r]rrr_log_deletion_activityrr3rrrrrJrKrL)r.r/rrc playlist_inforRr1r1r2r; sB     zPlaylistDeleteView.postcCs>ttjdd||jd}|||||d}t|d|S)a Handle GET request - show confirmation page. Args: request: Django HTTP request object playlist_id: ID of the playlist to delete Returns: Rendered confirmation template rFrar)rc dependencies can_deletezplaylists/confirm_delete.html)rr"r,rr+_get_playlist_dependenciesrr)r.r/rrcr0r1r1r2r37 s  zPlaylistDeleteView.getcCs&tj}|j|kr"|jdkr"dSdS)z Check if playlist can be safely deleted. Args: playlist: Playlist model instance Returns: bool: True if playlist can be deleted r0FT)rPrrr^rbrr1r1r2rP s z'PlaylistDeleteView._can_delete_playlistcCsf|jD]"}|jD]}|jqq |jD]}|jq8|j|dSrrrr1r1r2rd s z+PlaylistDeleteView._delete_playlist_cascadecCsf|jddd}|jD]D}|j}|d|7<|jD]}|d|j7<qDq|S)z Get information about playlist dependencies. Args: playlist: Playlist model instance Returns: dict: Dependencies information r)rrrrr)rrrrr)r.rcrr avails_countrr1r1r2r| s  z-PlaylistDeleteView._get_playlist_dependenciesc CsZzHtdtjd|jd|dd|dd|dd d }|Wn YnXd S) z Log playlist deletion activity. Args: user: User who deleted the playlist playlist_info: Dictionary with playlist information zDelete Playlistrz deleted playlist ID: rrrrFz (Broadcast: r^)rN)rrPr%rr)r.r+rrr1r1r2r s* z)PlaylistDeleteView._log_deletion_activitycCs6|jddkrtd|dSt||tdSdS)a Handle deletion errors for both AJAX and regular requests. Args: request: Django HTTP request object error_message: Error message string Returns: JsonResponse or HttpResponse redirect rrFrr6Nrr3rrr:rr.r/rr1r1r2r s  z'PlaylistDeleteView._handle_delete_errorN) rrrrr;r3rrrrrr1r1r1r2r s:rc@sXeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ dS)PlaylistDuplicateViewzN Class-based view for duplicating playlists with all related objects. c CszJttjdd||jd}|jd}|jdddk}|rztj |d }Wqt k r|| |d YWSXntj tjd d }|||r| |d |d WSt||||}W5QRX||j|||jddkr&tdd|d|jtd|jgddWSt|d|dtd|jdWSWn`tjk rp| |dYStk r}z| |dt|WYSd}~XYnXdS)z Handle playlist duplication. Args: request: Django HTTP request object playlist_id: ID of the playlist to duplicate Returns: JsonResponse or HttpResponse redirect rFrarr^as_draftfalsetruerzInvalid broadcast date format.rUrzA playlist already exists for z on this channel.rrTz%Playlist duplicated successfully for .rf)args)rrZnew_playlist_id redirect_urlrgzOriginal playlist not found.zError duplicating playlist: N)rr"r,rr+r7r3lowerrPrQrrO_handle_duplicate_errorrr&_playlist_exists_for_daterr_duplicate_playlist_structure_log_duplication_activityrrrhr rrrrJrKrL) r.r/roriginal_playlistZnew_broadcast_dateZ copy_as_draftnew_date new_playlistrRr1r1r2r; sT         zPlaylistDuplicateView.postcCsNttjdd||jd}||}||tjtj ddd}t |d|S)z Show duplication form. Args: request: Django HTTP request object playlist_id: ID of the playlist to duplicate Returns: Rendered duplication form template rFrarrUr)rcsuggested_datesZ default_datezplaylists/duplicate_form.html) rr"r,rr+_get_suggested_datesrPrrr&r)r.r/rrcrr0r1r1r2r3 s   zPlaylistDuplicateView.getcCstjj|j|j|dS)a Check if a playlist already exists for the target date. Args: original_playlist: Original playlist instance target_date: Target broadcast date Returns: bool: True if playlist exists for the date )r>rBr^)r"r,r-r>rBexists)r.rZ target_dater1r1r2r&s z/PlaylistDuplicateView._playlist_exists_for_datec Cst|jd||d|d|j|r&dnd|r0dndd}|d}|jdD]}|||\}}t||||j d} | |j d D]j} | | |} t | | | j tjd } | | jd D](} |d 7}t| | j| j|d }|qqqT|S)a0 Duplicate the entire playlist structure. Args: original_playlist: Original playlist instance new_date: New broadcast date as_draft: Whether to create as draft Returns: Playlists: New playlist instance r-rrr0)r>r]r^r_r`rBrbrTrrrrrZid_adspotsinAvailrU)r id_adspotrr)r"r>rBrrrr_calculate_new_window_timesr#r~r_calculate_new_avail_startr$rrPr%rr%rr)r.rrrrZtraffic_counteroriginal_windowZnew_window_startZnew_window_end new_windoworiginal_availZnew_avail_start new_availZ original_adZnew_adr1r1r2r7sV     z3PlaylistDuplicateView._duplicate_playlist_structurecCsD|j}|j}tj||}tj||}|d|dfS)a Calculate new window start and end times for the new date. Args: original_window: Original window instance new_date: New broadcast date Returns: tuple: (new_start_time, new_end_time) r)r|r}rPrrir)r.rroriginal_startZ original_end new_startZnew_endr1r1r2r|s z1PlaylistDuplicateView._calculate_new_window_timescCs"|j}tj||}|dS)z Calculate new avail start time for the new date. Args: original_avail: Original avail instance new_date: New broadcast date Returns: str: New avail start time r)rrPrrir)r.rrrrr1r1r2rs z0PlaylistDuplicateView._calculate_new_avail_startcCsbg}tjtjdd}tdD]:}|||s<|||tjdd7}t|dkr"q^q"|S)z Get suggested dates for duplication (next 7 days without existing playlists). Args: playlist: Original playlist instance Returns: list: List of suggested dates rUrr)rPrrr&rrrr~)r.rcrZ current_daterr1r1r2rs     z*PlaylistDuplicateView._get_suggested_datesc CsTzBtdtjd|jd|jd|jd|jd d}|Wn YnXdS) z Log playlist duplication activity. Args: user: User who duplicated the playlist original_playlist: Original playlist instance new_playlist: New playlist instance zDuplicate Playlistrz duplicated playlist ID: z to new playlist ID: z (New broadcast date: rrN)rrPr%rrhr^r)r.r+rrrr1r1r2rs $ z/PlaylistDuplicateView._log_duplication_activitycCs6|jddkrtd|dSt||tdSdS)a Handle duplication errors for both AJAX and regular requests. Args: request: Django HTTP request object error_message: Error message string Returns: JsonResponse or HttpResponse redirect rrFrr6Nrrr1r1r2rs  z-PlaylistDuplicateView._handle_duplicate_errorN) rrrrr;r3rrrrrrrr1r1r1r2r sFEr)EospytzjsonrirequestsrP django.viewsr django.dbrrrrdjango.contribr django.urlsrr django.db.modelsr r r r django.httprrdjango.core.exceptionsrdjango.utils.decoratorsrdjango.views.decorators.csrfrdjango.views.genericrrdjango.contrib.auth.mixinsrdjango.contrib.auth.decoratorsrdjango.views.decorators.httprdjango.shortcutsrrrdjango.core.paginatorrrrrest_framework.viewsrapps.common.utilsrapps.channels.modelsr r!apps.playlists.modelsr"r#r$r%apps.playlists.utilsr&r'rrrrrr1r1r1r2st              %8xI