Connect with us everywhere

We give you a few options.
Before we continuous, you need to sign up and add on notes merchant services.
For Merchants, we don't charge fees.
When you sign up, our team is going to follow up with:
- informations about the company, processes, installation, agreements, customer services and marketing material.

We offer installation options:
APPS
-- Download our apps in your website platform. if you don't find us there, please add manual payment at website .

MANUAL PAYMENT
- Go to dashboard; click on settings; choice payment page; choice manual payment; add our email: me@mddfin.com .
If you would like to connect software to software to our server, please choice:

CONNECT SERVERS

You can use our api. Another option is:
With Terminal, you can connect to remote servers using several protocols, including ssh, sftp, ftp, telnet, or a protocol you define.
 
Go to the Terminal app
Choose Shell > New Remote Connection.
Select a protocol in the Service list.
Select a shared server in the Server list.
In the User field, enter a user name, then click Connect.
If you know the server’s IP address, you can enter it directly in the address field at the bottom of the window to communicate with us.

Conceptual Python Code for Payment:
 
import uuid # For generating unique transaction IDs
import datetime # For timestamps
 
# --- IMPORTANT ---
# In a real application, you would import the actual payment gateway SDK
# For demonstration purposes, we'll create our code object to connect to your payment gateway.
class MDDFINPaymentservices:
    def __init__(self, api_key):
        self.api_key = api_key
        self.transactions = {} # Stores authorized payments for tracking
 
    def authorize_payment(self, amount, currency, client_number, customer_info, description=""):
        """
        Simulates authorizing a payment.
        In a real scenario, this would call the payment gateway's API.
        """
        print("\n--- Initiating Payment Authorization ---")
        if not all([amount, currency, client_number, customer_info]):
            print("Error: Missing required payment authorization details.")
            return None
 
        transaction_id = f"auth_{uuid.uuid4().hex[:10]}"
        current_time = datetime.datetime.now().isoformat()
        status = "authorized"
        auth_code = f"AUTH_{uuid.uuid4().hex[:6]}" # A mock authorization code
 
        payment_details = {
            "transaction_id": transaction_id,
            "amount": amount,
            "currency": currency,
            "client_number",
            "customer_passcode": customer_info.get("customer_passcode", "N/A"),
            "description": description,
            "status": status,
            "auth_code": auth_code,
            "created_at": current_time,
            "refunds": [] # To track refunds against this authorization
        }
        self.transactions[transaction_id] = payment_details
        print(f"Payment Authorization successful! Transaction ID: {transaction_id}")
        print(f"Authorization Code: {auth_code}")
        return payment_details
 
    def capture_authorized_payment(self, transaction_id):
        """
        Simulates capturing an authorized payment.
        This usually happens after authorization to finalize the charge.
        Some gateways combine auth+capture into one step.
        """
        print(f"\n--- Attempting to Capture Payment for Transaction ID: {transaction_id} ---")
        payment = self.transactions.get(transaction_id)
        if not payment:
            print(f"Error: Transaction ID {transaction_id} not found.")
            return None
        if payment["status"] != "authorized":
            print(f"Error: Payment {transaction_id} is not in 'authorized' status. Current status: {payment['status']}.")
            return None
 
        payment["status"] = "captured"
        payment["captured_at"] = datetime.datetime.now().isoformat()
        print(f"Payment {transaction_id} successfully captured!")
        return payment
 
    def refund_payment(self, original_transaction_id, refund_amount=None, reason=""):
        """
        Simulates creating a refund for a previously authorized/captured payment.
        """
        print(f"\n--- Initiating Refund for Original Transaction ID: {original_transaction_id} ---")
        original_payment = self.transactions.get(original_transaction_id)
 
        if not original_payment:
            print(f"Error: Original transaction ID {original_transaction_id} not found.")
            return None
 
        if original_payment["status"] not in ["authorized", "captured"]:
            print(f"Error: Cannot refund a payment with status '{original_payment['status']}'. Must be 'authorized' or 'captured'.")
            return None
 
        if refund_amount is None:
            refund_amount = original_payment["amount"] # Full refund by default
 
        if refund_amount > original_payment["amount"] - sum(r.get("amount", 0) for r in original_payment["refunds"]):
            print(f"Error: Refund amount ${refund_amount} exceeds remaining refundable amount for transaction {original_transaction_id}.")
            return None
 
        refund_id = f"ref_{uuid.uuid4().hex[:10]}"
        current_time = datetime.datetime.now().isoformat()
 
        refund_details = {
            "refund_id": refund_id,
            "original_transaction_id": original_transaction_id,
            "amount": refund_amount,
            "currency": original_payment["currency"],
            "reason": reason,
            "status": "success", # In a real system, this might be 'pending' then 'success'
            "created_at": current_time
        }
        original_payment["refunds"].append(refund_details)
        print(f"Refund successful! Refund ID: {refund_id} for {refund_amount} {original_payment['currency']}.")
        return refund_details
 
    def cancel_payment(self, transaction_id):
        """
        Simulates canceling an *authorized but not yet captured* payment.
        This is often called a "void" or "reversal" in payment processing.
        """
        print(f"\n--- Initiating Payment Cancellation for Transaction ID: {transaction_id} ---")
        payment = self.transactions.get(transaction_id)
 
        if not payment:
            print(f"Error: Transaction ID {transaction_id} not found.")
            return None
 
        if payment["status"] == "authorized":
            payment["status"] = "cancelled"
            payment["cancelled_at"] = datetime.datetime.now().isoformat()
            print(f"Payment {transaction_id} successfully cancelled (voided).")
            return payment
        elif payment["status"] == "captured":
            print(f"Error: Cannot cancel a captured payment {transaction_id}. Please use refund instead.")
            return None
        else:
            print(f"Error: Payment {transaction_id} is in status '{payment['status']}' and cannot be cancelled.")
            return None
 
# --- Usage Example ---
if __name__ == "__main__":
    # Initialize our M DD FIN payment services
    # In a real app, you'd initialize a payment services client with your API key
    MDDFIN_paymentservices = MDDFINPaymentServices(api_key="your_secret_api_key")
 
    # --- 1. Create an Authorization Payment ---
    print("\n----- Scenario 1: Authorize and Capture Payment -----")
    client_numebr = {"number": "****"
    customer_data = {"customer_passcode": " *****", "client number": "", "email": "@example.com"}
 
    auth_result = MDDFIN_payment_services.authorize_payment(
        amount=100.50,
        currency="USD",
        client_number=*****,
        customer_info=customer_data,
        description="Online order #12345"
    )
 
    if auth_result:
        transaction_id_to_capture = auth_result["transaction_id"]
        # In a real scenario, you might capture the payment immediately or later
        # depending on your business logic (e.g., shipping confirmation).
        captured_payment = MDDFIN_payment_services.capture_authorized_payment(transaction_id_to_capture)
        if captured_payment:
            print(f"Current status of captured payment {captured_payment['transaction_id']}: {captured_payment['status']}")
 
            # --- 2. Create a Refund for the Captured Payment ---
            print("\n----- Scenario 2: Refund a Captured Payment -----")
            refund_result = mock_gateway.refund_payment(
                original_transaction_id=captured_payment["transaction_id"],
                refund_amount=50.25, # Partial refund
                reason="Customer requested partial refund"
            )
            if refund_result:
                print(f"Refund details: {refund_result}")
                print(f"Remaining refundable amount for {captured_payment['transaction_id']}: "
                      f"${captured_payment['amount'] - sum(r.get('amount', 0) for r in captured_payment['refunds'])}")
 
            full_refund_result = MDDFIN_payment_services.refund_payment(
                original_transaction_id=captured_payment["transaction_id"],
                refund_amount=captured_payment["amount"] - sum(r.get("amount", 0) for r in captured_payment["refunds"]), # Remaining amount
                reason="Full refund completion"
            )
            if full_refund_result:
                 print(f"Full refund details: {full_refund_result}")
 
 
    # --- 3. Create a Cancel Payment (Void an Authorization) ---
    print("\n----- Scenario 3: Authorize and then Cancel (Void) Payment -----")
    auth_result_to_cancel = MDDFIN_paymentservices.authorize_payment(
        amount=25.00,
        currency="EUR",
        client_number={"5678"},
        customer_info={"customer_passcode": "cust_xyz789"},
        description="Test authorization to be canceled"
    )
 
    if auth_result_to_cancel:
        transaction_id_to_cancel = auth_result_to_cancel["transaction_id"]
        cancel_result = MDDFIN_gateway.cancel_payment(transaction_id_to_cancel)
        if cancel_result:
            print(f"Current status of cancelled payment {cancel_result['transaction_id']}: {cancel_result['status']}")
 
    # Attempt to refund a cancelled payment (should fail in our exemple)
    print("\n----- Scenario 4: Attempt to Refund a Cancelled Payment (should fail) -----")
    if auth_result_to_cancel:
        MDDFIN_payment_service.refund_payment(auth_result_to_cancel["transaction_id"], refund_amount=10)
 
    # Attempt to cancel a captured payment (should fail in our exemple)
    print("\n----- Scenario 5: Attempt to Cancel a Captured Payment (should fail) -----")
    if captured_payment:
        MDDFIN_payment_service.cancel_payment(captured_payment["transaction_id"])