Published on

From Manual Tedium to Automated Solution: The Development Story of Duoink PTE Invitation Tool

Authors
  • avatar
    Name
    Jack Qin
    Twitter

The Problem: A Mountain of Invitation Codes

As a frequent user of Duoink's PTE practice platform, I found myself in an unusual situation. Through various promotions and sharing events on Rednote (小红书), I had accumulated a substantial number of invitation codes that could extend my access to premium features. Each code represented additional practice time – valuable for someone preparing for the PTE Academic exam.

However, I quickly encountered a frustrating reality: redeeming these codes was an extraordinarily tedious process. Each code redemption required the same sequence of actions:

  1. Navigate to the Duoink platform
  2. Log in through WeChat authentication
  3. Locate the invitation code redemption page
  4. Enter a single code (in the format XXX-XXX-XXX)
  5. Click the redemption button
  6. Confirm the action in a dialog
  7. Wait for success/failure notification
  8. Return to the redemption page for the next code

While redeeming one or two codes was manageable, the prospect of manually processing dozens became daunting. Each code took approximately 30-45 seconds to process – not including the initial login time. With around 100 codes collected, this would consume over an hour of monotonous, repetitive clicking.

As a developer, I recognized this as a perfect candidate for automation. The process was:

  • Highly repetitive
  • Followed a consistent pattern
  • Required minimal decision-making
  • Had clear success/failure conditions

Conceptualizing the Solution

The solution seemed straightforward: create a script that could automate browser interactions to handle the entire redemption process. However, several challenges needed addressing:

  1. Authentication Complexity: Duoink uses WeChat QR code authentication, which can't be fully automated without security concerns.
  2. Response Variability: Codes might be valid, already used, invalid, or trigger unexpected responses.
  3. Platform Limitations: Duoink likely imposes daily redemption limits to prevent abuse.
  4. Tracking Mechanism: Keeping track of used and failed codes would be essential for multi-day processing.
  5. Ethical Considerations: Creating a tool that respects the platform's terms and doesn't enable excessive automation.

I decided to design a solution that would:

  • Require manual WeChat QR code scanning (preserving security)
  • Automatically process multiple codes after successful authentication
  • Intelligently handle different response scenarios
  • Track results to avoid reprocessing codes
  • Include reasonable limitations to prevent platform abuse

Technical Approach and Implementation

Technology Selection

For this automation task, I selected:

  • Python: A versatile language with excellent support for automation tasks
  • Selenium: A robust browser automation framework
  • Chrome WebDriver: For controlling Chrome browser instances
  • WebDriver Manager: To handle driver compatibility dynamically

These technologies offered a balance of power, flexibility, and ease of implementation. Selenium in particular excels at automating web interactions that follow predictable patterns.

Core Implementation Challenges

1. WeChat Authentication Handling

The first significant challenge was navigating the WeChat authentication flow. Since this requires a manual QR code scan, I designed the script to:

  1. Launch a browser window with the login page
  2. Display the WeChat QR code
  3. Wait for the user to scan it with their phone
  4. Detect successful authentication
  5. Proceed with code processing automatically after login

This approach maintained security while minimizing user involvement to a single scan action.

def login_to_duoink(driver):
    # Navigate to the login page
    driver.get("https://www.duoink.com/login")

    # Wait for the WeChat QR code to appear
    qr_code_element = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.CLASS_NAME, "login-qrcode"))
    )

    print("⚠️ Please scan the WeChat QR code displayed in the browser window")
    print("Waiting for login (60 seconds timeout)...")

    # Wait for login to complete (looking for an element that appears after successful login)
    try:
        WebDriverWait(driver, 60).until(
            EC.presence_of_element_located((By.CLASS_NAME, "user-profile"))
        )
        print("✅ Login successful!")
        return True
    except TimeoutException:
        print("❌ Login timeout. Please try again.")
        return False

2. Intelligent Code Processing System

The most complex part of the implementation was creating a robust system to process invitation codes with appropriate error handling. The system needed to:

  • Read codes from a file
  • Submit each code through the web interface
  • Interpret various response messages
  • Categorize results (success, already used, invalid, etc.)
  • Update tracking files accordingly

This required careful element selection and a well-structured response handling system:

def process_invitation_code(driver, code):
    try:
        # Navigate to the invitation code page
        driver.get("https://www.duoink.com/invitation")

        # Wait for the input field and enter the code
        code_input = WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "invitation-code-input"))
        )
        code_input.clear()
        code_input.send_keys(code)

        # Click the redeem button
        redeem_button = driver.find_element(By.ID, "redeem-button")
        redeem_button.click()

        # Wait for confirmation dialog and confirm
        confirm_button = WebDriverWait(driver, 5).until(
            EC.presence_of_element_located((By.CLASS_NAME, "confirm-btn"))
        )
        confirm_button.click()

        # Wait for response message
        response_message = WebDriverWait(driver, 5).until(
            EC.presence_of_element_located((By.CLASS_NAME, "response-message"))
        )

        message_text = response_message.text.strip()

        # Process different response scenarios
        if "successfully redeemed" in message_text:
            return "SUCCESS"
        elif "already been used" in message_text:
            return "ALREADY_USED"
        elif "invalid code" in message_text:
            return "INVALID"
        else:
            return "UNKNOWN"

    except Exception as e:
        print(f"Error processing code {code}: {str(e)}")
        return "ERROR"

3. Comprehensive File Management

To track progress across multiple sessions, I implemented a file management system that:

  1. Maintains separate files for:

    • Available invitation codes
    • Successfully redeemed codes
    • Failed/error codes

  2. Updates these files in real-time as codes are processed

  3. Checks existing files before processing to avoid duplicate attempts

def get_codes_to_process():
    # Read all available codes
    with open("invitation_code.txt", "r") as f:
        all_codes = [line.strip() for line in f if line.strip()]

    # Read already used codes if the file exists
    used_codes = []
    if os.path.exists("used_code.txt"):
        with open("used_code.txt", "r") as f:
            used_codes = [line.strip() for line in f if line.strip()]

    # Read error codes if the file exists
    error_codes = []
    if os.path.exists("error_code.txt"):
        with open("error_code.txt", "r") as f:
            error_codes = [line.strip() for line in f if line.strip()]

    # Filter out codes that have already been processed
    codes_to_process = [code for code in all_codes
                        if code not in used_codes and code not in error_codes]

    return codes_to_process

Putting It All Together

The main script orchestrates these components into a cohesive workflow:

  1. Read codes that need processing (filtering out already processed ones)
  2. Initialize the browser and handle login
  3. Process each code systematically, with appropriate pauses between actions
  4. Track and report results
  5. Clean up resources when complete

This structured approach ensured reliability while maintaining respect for the platform's intended usage patterns.

Ethical Considerations and Implementation Decisions

Throughout development, I maintained a focus on ethical automation:

  1. Limited Default Codes: I deliberately included only 30 invitation codes in the default file to discourage excessive usage.

  2. Manual Authentication: By requiring manual QR code scanning, the tool preserves the platform's security model and prevents unauthorized access.

  3. Responsible Usage Statement: I included a clear statement in the documentation encouraging users to support the platform by purchasing memberships if financially able.

  4. Rate Limiting: The script includes deliberate pauses between actions to avoid overwhelming the server.

  5. Transparent Documentation: All functionality is clearly documented, with no hidden capabilities.

These decisions reflect my belief that automation tools should enhance legitimate user activities, not enable abuse or circumvention of platform limitations.

Testing and Refinement

The testing process revealed several challenges that required additional refinement:

Challenge 1: Element Detection Reliability

Early versions sometimes failed to locate elements due to timing issues or slight UI variations. I improved reliability by:

  1. Implementing multiple fallback selectors for critical elements
  2. Adding more robust waiting mechanisms
  3. Incorporating exception handling with graceful degradation

Challenge 2: Response Message Variability

The platform occasionally returned unexpected response formats. I enhanced the response processing logic to:

  1. Handle partial message matches
  2. Recognize common error patterns
  3. Provide meaningful feedback for unexpected scenarios

Challenge 3: Session Management

Browser sessions sometimes expired during extended processing. I addressed this by:

  1. Adding session detection and refresh capabilities
  2. Implementing automatic recovery from most common session issues
  3. Preserving progress information to allow resuming after unexpected interruptions

Each refinement cycle improved the tool's stability and usability, resulting in a robust final product.

Results and Impact

The completed Duoink PTE Invitation Tool transformed what would have been hours of tedious manual work into a largely automated process requiring minimal intervention. The impact was significant:

  1. Time Efficiency: Reduced code redemption time from ~30-45 seconds per code to approximately 5-8 seconds per code (after initial authentication).

  2. Error Reduction: Eliminated human error in code entry and tracking.

  3. Progress Tracking: Provided clear visibility into redemption status and history.

  4. Platform Respect: Maintained compliance with platform limitations and terms.

The tool proved particularly valuable over multiple days of processing, as it intelligently tracked which codes had already been processed and seamlessly continued with remaining codes.

Lessons Learned

This project reinforced several important principles about automation development:

  1. Balance Automation with Security: Finding the right balance between automation and security (manual QR code scanning) created a more responsible tool.

  2. Plan for Variability: Web interfaces change, and responses vary. Building flexibility into element detection and response handling was crucial.

  3. Progressive Enhancement: Starting with basic functionality and iteratively adding features allowed for better testing and refinement.

  4. Ethical Considerations Matter: Designing with platform respect and legitimate use cases in mind created a more sustainable solution.

  5. Documentation is Essential: Clear documentation of both capabilities and limitations helps users understand how to use the tool responsibly.

The development of this tool also demonstrated how often developers create their most useful tools by solving their own problems. By addressing my personal frustration with code redemption, I created a solution that could benefit others facing the same challenge.

Future Improvements

While the current version effectively meets the core requirements, several potential improvements have been identified for future releases:

  1. Enhanced Reporting: More detailed statistics and visual reporting of redemption results.

  2. Configuration Options: User-configurable settings for timing, retry attempts, and other parameters.

  3. Improved Error Recovery: More sophisticated recovery mechanisms for edge-case failures.

  4. Headless Operation Option: Support for running in headless browser mode for advanced users.

  5. Multi-Platform Support: Extending support to other browsers beyond Chrome.

These enhancements would further improve the tool's flexibility and reliability while maintaining its core ethical principles.

Conclusion

The Duoink PTE Invitation Tool represents a successful application of automation to transform a repetitive, time-consuming task into an efficient, reliable process. By focusing on both technical excellence and ethical considerations, the tool provides genuine value while respecting platform limitations.

This development journey illustrates how identifying common frustrations can lead to valuable solutions. What began as a personal utility evolved into a tool that others can benefit from, demonstrating the power of applying technical skills to everyday challenges.

For those interested in exploring the code further or contributing to its development, the project is available on GitHub under an MIT license, welcoming contributions and improvements from the developer community.

Note: The Duoink PTE Invitation Tool is intended for legitimate use by individuals with valid invitation codes. The author and contributors do not endorse or support any usage that violates platform terms or conditions.