Django ਵਿੱਚ "ਕੋਈ ਚਿੱਤਰ ਮੁਹੱਈਆ ਨਹੀਂ" ਗਲਤੀ ਅਤੇ 400 31 ਜਵਾਬ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ jQuery AJAX ਦੀ ਵਰਤੋਂ ਕਰਨਾ

Django ਅਤੇ jQuery ਵਿੱਚ ਚਿੱਤਰ ਅੱਪਲੋਡਾਂ ਦਾ ਨਿਪਟਾਰਾ ਕਰਨਾ

Django ਅਤੇ jQuery ਦੇ ਨਾਲ ਇੱਕ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਂਦੇ ਸਮੇਂ, ਫਾਈਲਾਂ ਦੇ ਅਪਲੋਡਾਂ ਨੂੰ ਸੰਭਾਲਣਾ, ਜਿਵੇਂ ਕਿ ਚਿੱਤਰ, ਕਈ ਵਾਰ ਚੁਣੌਤੀਆਂ ਪੈਦਾ ਕਰ ਸਕਦੇ ਹਨ। AJAX ਬੇਨਤੀ ਦੁਆਰਾ ਇੱਕ ਚਿੱਤਰ ਨੂੰ ਅੱਪਲੋਡ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਸਮੇਂ ਡਿਵੈਲਪਰਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨ ਵਾਲੀ ਇੱਕ ਆਮ ਸਮੱਸਿਆ ਸਰਵਰ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਵਾਪਸ ਕਰਨਾ ਹੈ। ਇਹ ਗਲਤੀਆਂ ਨਿਰਾਸ਼ਾਜਨਕ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਫਰੰਟਐਂਡ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰ ਰਿਹਾ ਜਾਪਦਾ ਹੈ, ਪਰ ਬੈਕਐਂਡ ਫਾਈਲ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਤੋਂ ਇਨਕਾਰ ਕਰਦਾ ਹੈ।

ਇਹ ਮੁੱਦਾ ਅਕਸਰ "ਕੋਈ ਚਿੱਤਰ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ" ਵਰਗੇ ਸੁਨੇਹਿਆਂ ਦੇ ਨਾਲ ਇੱਕ HTTP 400 ਜਵਾਬ ਵਜੋਂ ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਡਿਵੈਲਪਰ ਹੈਰਾਨ ਹੁੰਦੇ ਹਨ ਕਿ ਕੀ ਗਲਤ ਹੋਇਆ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਫਰੰਟਐਂਡ ਸਰਵਰ ਨੂੰ ਚਿੱਤਰ ਡੇਟਾ ਕਿਵੇਂ ਭੇਜਦਾ ਹੈ. ਫਰੰਟਐਂਡ ਅਤੇ ਬੈਕਐਂਡ ਵਿਚਕਾਰ ਸਹੀ ਸੰਚਾਰ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ ਨਿਰਵਿਘਨ ਫਾਈਲ ਹੈਂਡਲਿੰਗ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਅਸਲ-ਸੰਸਾਰ ਦ੍ਰਿਸ਼ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ ਜਿੱਥੇ AJAX ਦੁਆਰਾ ਇੱਕ ਚਿੱਤਰ ਅੱਪਲੋਡ "ਕੋਈ ਚਿੱਤਰ ਪ੍ਰਦਾਨ ਨਹੀਂ" ਗਲਤੀ ਅਤੇ Django ਵਿੱਚ ਇੱਕ 400 31 ਜਵਾਬ ਕੋਡ ਦੇ ਕਾਰਨ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ। ਅਸੀਂ ਮੂਲ ਕਾਰਨ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਫਰੰਟਐਂਡ ਅਤੇ ਬੈਕਐਂਡ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਾਂਗੇ ਅਤੇ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਹੱਲ ਪੇਸ਼ ਕਰਾਂਗੇ।

ਇਸ ਗਾਈਡ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਹਾਨੂੰ jQuery ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ Django ਸਰਵਰ ਨੂੰ ਚਿੱਤਰ ਫਾਈਲਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਭੇਜਣਾ ਹੈ, ਇਸ ਬਾਰੇ ਸਪਸ਼ਟ ਸਮਝ ਹੋਵੇਗੀ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਤੁਹਾਡੀਆਂ ਫਾਈਲ ਅਪਲੋਡ ਬੇਨਤੀਆਂ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਤਰੁੱਟੀ ਦੇ ਸਫਲਤਾਪੂਰਵਕ ਸੰਸਾਧਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।

ਹੁਕਮ	ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ
FormData()	ਇਹ ਕਮਾਂਡ ਇੱਕ ਨਵਾਂ ਫਾਰਮਡਾਟਾ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ AJAX ਰਾਹੀਂ ਡਾਟਾ ਭੇਜਣ ਲਈ ਕੁੰਜੀ/ਮੁੱਲ ਜੋੜਿਆਂ ਦਾ ਇੱਕ ਸੈੱਟ ਆਸਾਨੀ ਨਾਲ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਸ ਵਿੱਚ ਚਿੱਤਰਾਂ ਵਰਗੀਆਂ ਫ਼ਾਈਲਾਂ ਵੀ ਸ਼ਾਮਲ ਹਨ। ਫਾਈਲ ਅਪਲੋਡਸ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਇਹ ਟ੍ਰਾਂਸਮਿਸ਼ਨ ਲਈ ਡੇਟਾ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਫਾਰਮੈਟ ਕਰਦਾ ਹੈ।
processData: false	jQuery ਦੀਆਂ AJAX ਸੈਟਿੰਗਾਂ ਵਿੱਚ, ਇਹ ਕਮਾਂਡ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਭੇਜਿਆ ਜਾ ਰਿਹਾ ਡੇਟਾ ਪ੍ਰੋਸੈਸ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ ਜਾਂ ਇੱਕ ਪੁੱਛਗਿੱਛ ਸਤਰ ਵਿੱਚ ਬਦਲਿਆ ਨਹੀਂ ਗਿਆ ਹੈ। FormData ਵਸਤੂਆਂ ਨੂੰ ਭੇਜਣ ਵੇਲੇ ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ ਉਹਨਾਂ ਵਿੱਚ ਫਾਈਲਾਂ ਸ਼ਾਮਲ ਹੁੰਦੀਆਂ ਹਨ, ਜੋ ਉਹਨਾਂ ਦੇ ਕੱਚੇ ਰੂਪ ਵਿੱਚ ਭੇਜੀਆਂ ਜਾਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ।
contentType: false	ਇਹ ਸਰਵਰ ਨੂੰ ਸਮਗਰੀ-ਕਿਸਮ ਸਿਰਲੇਖ ਨੂੰ ਆਪਣੇ ਆਪ ਸੈੱਟ ਨਾ ਕਰਨ ਲਈ ਕਹਿੰਦਾ ਹੈ। ਫਾਈਲਾਂ ਅਪਲੋਡ ਕਰਨ ਵੇਲੇ ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਫਾਈਲ ਡੇਟਾ ਭੇਜਣ ਲਈ ਸਹੀ ਮਲਟੀਪਾਰਟ ਫਾਰਮ-ਡੇਟਾ ਸਮੱਗਰੀ ਕਿਸਮ ਦੀ ਸੀਮਾ ਤਿਆਰ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
request.FILES	Django ਵਿੱਚ, request.FILES ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਵਰਗੀ ਵਸਤੂ ਹੈ ਜਿਸ ਵਿੱਚ ਸਾਰੀਆਂ ਅੱਪਲੋਡ ਕੀਤੀਆਂ ਫ਼ਾਈਲਾਂ ਸ਼ਾਮਲ ਹਨ। ਇਹ ਫਾਈਲ ਅਪਲੋਡਸ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੁੰਜੀ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਕਲਾਇੰਟ-ਸਾਈਡ ਤੋਂ ਭੇਜੀਆਂ ਗਈਆਂ ਚਿੱਤਰ ਜਾਂ ਦਸਤਾਵੇਜ਼ ਫਾਈਲਾਂ ਤੱਕ ਪਹੁੰਚ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
SimpleUploadedFile()	ਇਹ ਫਾਈਲ ਅਪਲੋਡਾਂ ਦੀ ਨਕਲ ਕਰਨ ਲਈ Django ਦੇ ਟੈਸਟਿੰਗ ਫਰੇਮਵਰਕ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਇੱਕ ਸਧਾਰਨ ਫਾਈਲ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਇੱਕ ਅਸਲ ਫਾਈਲ ਅਪਲੋਡ ਦੀ ਨਕਲ ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਚਿੱਤਰ ਅੱਪਲੋਡ ਵਰਗੇ ਫਾਈਲ-ਹੈਂਡਲਿੰਗ ਦ੍ਰਿਸ਼ਾਂ ਲਈ ਯੂਨਿਟ ਟੈਸਟ ਲਿਖਣ ਦੀ ਆਗਿਆ ਮਿਲਦੀ ਹੈ।
JsonResponse()	JSON-ਫਾਰਮੈਟ ਕੀਤੇ HTTP ਜਵਾਬਾਂ ਨੂੰ ਵਾਪਸ ਕਰਨ ਲਈ ਇੱਕ Django ਵਿਧੀ। ਇਸ ਸੰਦਰਭ ਵਿੱਚ, ਇਸਦੀ ਵਰਤੋਂ ਗਾਹਕ ਨੂੰ ਗਲਤੀ ਸੰਦੇਸ਼ ਜਾਂ ਸਫਲਤਾ ਡੇਟਾ ਵਾਪਸ ਭੇਜਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ AJAX ਬੇਨਤੀਆਂ ਲਈ ਉਪਯੋਗੀ ਜੋ JSON ਡੇਟਾ ਦੀ ਉਮੀਦ ਕਰਦੇ ਹਨ।
@csrf_exempt	Django ਵਿੱਚ ਇਸ ਸਜਾਵਟ ਦੀ ਵਰਤੋਂ CSRF ਸੁਰੱਖਿਆ ਵਿਧੀ ਤੋਂ ਇੱਕ ਦ੍ਰਿਸ਼ ਨੂੰ ਛੋਟ ਦੇਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਹਾਲਾਂਕਿ ਇਹ ਤੇਜ਼ ਵਿਕਾਸ ਜਾਂ ਟੈਸਟਿੰਗ ਦੌਰਾਨ ਉਪਯੋਗੀ ਹੈ, ਇਸਦੀ ਵਰਤੋਂ ਸਾਵਧਾਨੀ ਨਾਲ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸੁਰੱਖਿਆ ਖਤਰਿਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰ ਸਕਦਾ ਹੈ।
readAsDataURL()	FileReader API ਤੋਂ ਇੱਕ JavaScript ਵਿਧੀ ਜੋ ਇੱਕ ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਪੜ੍ਹਦੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਬੇਸ64 ਡੇਟਾ URL ਦੇ ਰੂਪ ਵਿੱਚ ਏਨਕੋਡ ਕਰਦੀ ਹੈ। ਇਹ ਸਰਵਰ ਨੂੰ ਭੇਜਣ ਤੋਂ ਪਹਿਲਾਂ ਕਲਾਇੰਟ-ਸਾਈਡ 'ਤੇ ਚਿੱਤਰ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
append()	ਫਾਰਮਡਾਟਾ ਆਬਜੈਕਟ ਵਿੱਚ ਇਹ ਵਿਧੀ ਫਾਰਮ ਡੇਟਾ ਵਿੱਚ ਕੁੰਜੀ/ਮੁੱਲ ਜੋੜਿਆਂ ਨੂੰ ਜੋੜਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਇਹ ਫਾਈਲਾਂ ਨੂੰ ਅਟੈਚ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਚਿੱਤਰ ਫਾਈਲ ਨੂੰ AJAX ਰਾਹੀਂ ਭੇਜਣ ਤੋਂ ਪਹਿਲਾਂ ਫਾਰਮ ਵਿੱਚ ਜੋੜਨ ਵੇਲੇ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।

Django ਵਿੱਚ AJAX ਚਿੱਤਰ ਅੱਪਲੋਡ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਮਝਣਾ

ਉੱਪਰ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਇੱਕ ਆਮ ਸਮੱਸਿਆ ਨਾਲ ਨਜਿੱਠਦੀਆਂ ਹਨ ਜਦੋਂ ਅੱਗੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਲਈ AJAX ਦੁਆਰਾ ਇੱਕ Django ਬੈਕਐਂਡ ਵਿੱਚ ਇੱਕ ਚਿੱਤਰ ਅੱਪਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੱਥੇ ਮੁੱਖ ਚੁਣੌਤੀ CSRF ਸੁਰੱਖਿਆ ਵਰਗੇ ਸਹੀ ਸੁਰੱਖਿਆ ਉਪਾਵਾਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋਏ ਸਰਵਰ ਨੂੰ ਫਾਈਲ ਡੇਟਾ ਨੂੰ ਸਹੀ ਫਾਰਮੈਟ ਵਿੱਚ ਭੇਜਣਾ ਹੈ। ਫਰੰਟਐਂਡ ਵਰਤਦਾ ਹੈ ਚਿੱਤਰ ਅੱਪਲੋਡ ਨੂੰ ਸੰਭਾਲਣ ਲਈ. ਚਿੱਤਰ ਨੂੰ ਇੱਕ ਇਨਪੁਟ ਤੱਤ ਤੋਂ ਚੁਣਿਆ ਗਿਆ ਹੈ, ਅਤੇ API ਨੂੰ ਉਪਭੋਗਤਾ ਨੂੰ ਚਿੱਤਰ ਪੂਰਵਦਰਸ਼ਨ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਪ੍ਰੋਸੈਸ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵੈਬਪੇਜ 'ਤੇ ਚਿੱਤਰ ਨੂੰ ਦਿਖਾ ਕੇ ਇੱਕ ਹੋਰ ਇੰਟਰਐਕਟਿਵ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਬਣਾਉਂਦਾ ਹੈ।

ਚਿੱਤਰ ਨੂੰ ਚੁਣਨ ਤੋਂ ਬਾਅਦ, ਉਪਭੋਗਤਾ ਚਿੱਤਰ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ ਇੱਕ ਬਟਨ ਨੂੰ ਕਲਿਕ ਕਰ ਸਕਦਾ ਹੈ. ਇਸ ਮੌਕੇ 'ਤੇ, jQuery ਫੰਕਸ਼ਨ ਚਿੱਤਰ ਨੂੰ Django ਬੈਕਐਂਡ 'ਤੇ ਭੇਜਦਾ ਹੈ। ਸਿਰਫ਼ ਚਿੱਤਰ ਫਾਈਲ ਨਾਮ ਭੇਜਣ ਦੀ ਬਜਾਏ, ਸਕ੍ਰਿਪਟ ਹੁਣ ਵਰਤਦੀ ਹੈ CSRF ਟੋਕਨ ਸਮੇਤ ਹੋਰ ਜ਼ਰੂਰੀ ਫਾਰਮ ਡੇਟਾ ਦੇ ਨਾਲ ਅਸਲ ਫਾਈਲ ਨੂੰ ਜੋੜਨ ਲਈ। ਦ ਅਤੇ ਸਮੱਗਰੀ ਦੀ ਕਿਸਮ: ਗਲਤ AJAX ਬੇਨਤੀ ਵਿੱਚ ਸੈਟਿੰਗਾਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀਆਂ ਹਨ ਕਿ ਡੇਟਾ ਨੂੰ ਇੱਕ ਪੁੱਛਗਿੱਛ ਸਤਰ ਵਿੱਚ ਤਬਦੀਲ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਸਰਵਰ ਨੂੰ ਫਾਈਲਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਚਾਰਿਤ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਬੈਕਐਂਡ 'ਤੇ, Django ਵਿਊ ਵਰਤਦਾ ਹੈ ਅੱਪਲੋਡ ਚਿੱਤਰ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ. ਇਹ ਵਸਤੂ ਫਾਰਮ ਰਾਹੀਂ ਅੱਪਲੋਡ ਕੀਤੀਆਂ ਸਾਰੀਆਂ ਫ਼ਾਈਲਾਂ ਨੂੰ ਸਟੋਰ ਕਰਦੀ ਹੈ। ਦ੍ਰਿਸ਼ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਚਿੱਤਰ ਮੌਜੂਦ ਹੈ ਅਤੇ ਫਿਰ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ 'ਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਚਿੱਤਰ ਗੁੰਮ ਹੈ, ਤਾਂ ਸਰਵਰ ਇੱਕ 400 ਸਥਿਤੀ ਕੋਡ ਨੂੰ ਚਾਲੂ ਕਰਦੇ ਹੋਏ, "ਕੋਈ ਚਿੱਤਰ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤਾ" ਗਲਤੀ ਸੁਨੇਹੇ ਨਾਲ ਜਵਾਬ ਦਿੰਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਅਵੈਧ ਜਾਂ ਖਾਲੀ ਬੇਨਤੀਆਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ, ਵਧੇਰੇ ਸੁਰੱਖਿਅਤ ਅਤੇ ਮਜ਼ਬੂਤ ​​API ਸੰਚਾਰ ਵਿੱਚ ਯੋਗਦਾਨ ਪਾਉਂਦਾ ਹੈ।

ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਗਲਤੀ ਲੌਗਿੰਗ ਅਤੇ ਰਿਸਪਾਂਸ ਹੈਂਡਲਿੰਗ ਨੂੰ ਵੀ ਹੈਂਡਲ ਕਰਦੀ ਹੈ . ਜੇ ਚਿੱਤਰ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਸੰਸਾਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੱਕ 200 ਸਥਿਤੀ ਕੋਡ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਪ੍ਰੋਸੈਸਿੰਗ ਦੌਰਾਨ ਕੁਝ ਗਲਤ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ 500 ਸਥਿਤੀ ਕੋਡ ਦੇ ਨਾਲ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਵਾਪਸ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਟੈਸਟ ਸੂਟ ਸਕ੍ਰਿਪਟ ਵਰਤਦੀ ਹੈ ਯੂਨਿਟ ਟੈਸਟਿੰਗ ਦੌਰਾਨ ਫਾਈਲ ਅਪਲੋਡਾਂ ਦੀ ਨਕਲ ਕਰਨ ਲਈ। ਇਹ ਇਹ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਕਿ ਦ੍ਰਿਸ਼ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਚਿੱਤਰ ਫਾਈਲਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਪੂਰਾ ਪ੍ਰਵਾਹ ਵੱਖ-ਵੱਖ ਦ੍ਰਿਸ਼ਾਂ ਅਤੇ ਪਲੇਟਫਾਰਮਾਂ ਵਿੱਚ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰਦਾ ਹੈ।

// jQuery Script with FormData to send the image correctly
$(document).ready(() => {
    $("input[id='image']").on('change', function(event) {
        let input = this;
        var reader = new FileReader();
        reader.onload = function(e) {
            $('#banner').css('width', '350px')
            $('#banner').addClass('img-thumbnail')
            $('#banner').attr('src', e.target.result);
        }
        reader.readAsDataURL(input.files[0]);
    });

    $('#process').click(() => {
        let image = $('#image').prop('files')[0];
        let formData = new FormData();
        formData.append('image', image);
        formData.append('csrfmiddlewaretoken', '{{ csrf_token }}');

        $.ajax({
            url: "/api/",
            type: "POST",
            data: formData,
            processData: false,  // Required for FormData
            contentType: false,  // Required for FormData
            success: function(xhr) {
                alert("Image processed successfully!");
            },
            error: function(xhr) {
                console.log(xhr.responseText);
                alert("Error occurred while processing the image.");
            }
        });
    });
});

from django.shortcuts import render
from django.http import JsonResponse, HttpResponse
from django.views.decorators.csrf import csrf_exempt
from diab_retina_app import process

@csrf_exempt
def process_image(request):
    if request.method == 'POST':
        img = request.FILES.get('image')
        if img is None:
            return JsonResponse({'error': 'No image provided.'}, status=400)

        try:
            response = process.process_img(img)
            return HttpResponse(response, status=200)
        except ValueError as e:
            return JsonResponse({'error': str(e)}, status=500)

from django.test import TestCase, Client
from django.core.files.uploadedfile import SimpleUploadedFile

class ImageUploadTest(TestCase):
    def setUp(self):
        self.client = Client()

    def test_image_upload(self):
        # Create a fake image for testing
        img = SimpleUploadedFile("test_image.jpg", b"file_content", content_type="image/jpeg")

        response = self.client.post('/api/', {'image': img}, format='multipart')

        self.assertEqual(response.status_code, 200)
        self.assertIn("Result", response.content.decode())

AJAX ਅਤੇ Django ਵਿੱਚ ਫਾਈਲ ਅੱਪਲੋਡ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨਾ

ਬਹੁਤ ਸਾਰੀਆਂ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ, ਖਾਸ ਤੌਰ 'ਤੇ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲਾਂ ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਵਾਲੇ, ਫਾਈਲ ਅਪਲੋਡ ਆਮ ਹਨ। ਇੱਕ ਚੁਣੌਤੀ ਡਿਵੈਲਪਰਾਂ ਦਾ ਸਾਹਮਣਾ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੈ ਕਿ ਚਿੱਤਰ ਜਾਂ ਫਾਈਲ ਕਲਾਇੰਟ ਤੋਂ ਸਰਵਰ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਭੇਜੀ ਗਈ ਹੈ. ਇਸ ਵਿੱਚ ਸੰਭਾਲਣਾ ਸ਼ਾਮਲ ਹੈ ਪ੍ਰਭਾਵੀ ਢੰਗ ਨਾਲ ਬੇਨਤੀਆਂ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਫਾਈਲਾਂ ਨੂੰ ਸਰਵਰ ਦੁਆਰਾ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੇ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸ ਪ੍ਰਵਾਹ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕਾਰਕ ਚਿੱਤਰ ਫਾਈਲਾਂ ਭੇਜਣ ਲਈ ਸਹੀ ਫਾਰਮੈਟ ਦੀ ਵਰਤੋਂ ਕਰ ਰਿਹਾ ਹੈ। ਦ ਆਬਜੈਕਟ ਇੱਕ ਜ਼ਰੂਰੀ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਫਾਈਲਾਂ ਨੂੰ ਦੂਜੇ ਡੇਟਾ, ਜਿਵੇਂ ਕਿ CSRF ਟੋਕਨ, Django ਵਿੱਚ ਜੋੜਿਆ ਅਤੇ ਸੰਚਾਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਸਮਝਣ ਲਈ ਇੱਕ ਹੋਰ ਮੁੱਖ ਨੁਕਤਾ Django ਈਕੋਸਿਸਟਮ ਵਿੱਚ ਫਰੰਟਐਂਡ ਅਤੇ ਬੈਕਐਂਡ ਕੰਪੋਨੈਂਟਸ ਵਿਚਕਾਰ ਆਪਸੀ ਤਾਲਮੇਲ ਹੈ। ਸਰਵਰ ਨੂੰ ਇੱਕ ਚਿੱਤਰ ਭੇਜਣ ਲਈ AJAX ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਫਰੰਟਐਂਡ ਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਡੇਟਾ ਇੱਕ ਪੁੱਛਗਿੱਛ ਸਤਰ ਵਿੱਚ ਏਨਕੋਡ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਫਾਈਲ ਅੱਪਲੋਡ ਨੂੰ ਤੋੜ ਸਕਦਾ ਹੈ। Django ਪਾਸੇ 'ਤੇ, the ਡਿਕਸ਼ਨਰੀ ਨੂੰ ਅਪਲੋਡ ਕੀਤੀ ਫਾਈਲ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕੈਪਚਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਡਿਵੈਲਪਰਾਂ ਦੀ ਇੱਕ ਆਮ ਗਲਤੀ AJAX ਕਾਲ 'ਤੇ ਢੁਕਵੇਂ ਸਿਰਲੇਖ ਜਾਂ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਸੈੱਟ ਨਹੀਂ ਕਰਨਾ ਹੈ, ਜਿਸ ਨਾਲ "ਕੋਈ ਚਿੱਤਰ ਮੁਹੱਈਆ ਨਹੀਂ" ਵਰਗੀਆਂ ਗਲਤੀਆਂ ਹੁੰਦੀਆਂ ਹਨ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਫਰੰਟਐਂਡ ਅਤੇ ਬੈਕਐਂਡ ਦੋਵਾਂ ਵਿੱਚ ਗਲਤੀ ਦੇ ਪ੍ਰਬੰਧਨ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣਾ ਇੱਕ ਨਿਰਵਿਘਨ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਗਲਤੀਆਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਫੜਨਾ ਅਤੇ ਲੌਗ ਕਰਨਾ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਡੀਬੱਗ ਕਰਨ ਅਤੇ ਹੱਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਪੂਰੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਿਵੇਂ ਕਿ ਸਾਧਨਾਂ ਨਾਲ Django ਦੇ ਟੈਸਟ ਸੂਟ ਵਿੱਚ, ਡਿਵੈਲਪਰ ਆਪਣੀ ਫਾਈਲ ਅਪਲੋਡ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹਨ ਕਿ ਸਿਸਟਮ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਅਤੇ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ ਸਹੀ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ। ਇਹ ਪਹੁੰਚ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਂਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਵੱਡੀਆਂ ਤਸਵੀਰਾਂ ਜਾਂ ਡੇਟਾ ਫਾਈਲਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ।

1. ਮੈਨੂੰ "ਕੋਈ ਚਿੱਤਰ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ" ਗਲਤੀ ਕਿਉਂ ਮਿਲ ਰਹੀ ਹੈ?
2. ਸਭ ਤੋਂ ਆਮ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਚਿੱਤਰ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਜੋੜਿਆ ਨਹੀਂ ਗਿਆ ਹੈ AJAX ਬੇਨਤੀ ਵਿੱਚ ਵਸਤੂ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਵਰਤੋਂ ਕਰਦੇ ਹੋ ਚਿੱਤਰ ਫਾਈਲ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ.
3. ਕੀ ਹੈ Django ਵਿੱਚ?
4. Django ਵਿੱਚ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਹੈ ਜੋ ਇੱਕ ਫਾਰਮ ਦੁਆਰਾ ਅੱਪਲੋਡ ਕੀਤੀਆਂ ਸਾਰੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਰੱਖਦਾ ਹੈ, ਬੈਕਐਂਡ ਨੂੰ ਫਾਈਲਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
5. ਮੈਂ ਇੱਕ AJAX ਬੇਨਤੀ ਵਿੱਚ ਇੱਕ ਫਾਈਲ ਕਿਵੇਂ ਜੋੜਾਂ?
6. ਤੁਹਾਨੂੰ ਇੱਕ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ ਵਸਤੂ ਅਤੇ ਵਰਤੋਂ AJAX ਦੁਆਰਾ ਭੇਜਣ ਤੋਂ ਪਹਿਲਾਂ ਫਾਈਲ ਨੂੰ ਜੋੜਨ ਦਾ ਤਰੀਕਾ.
7. ਮੈਨੂੰ ਕਿਉਂ ਲੋੜ ਹੈ AJAX ਵਿੱਚ?
8. ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ AJAX ਬੇਨਤੀ ਵਿੱਚ ਭੇਜੇ ਗਏ ਡੇਟਾ ਨੂੰ ਇੱਕ ਪੁੱਛਗਿੱਛ ਸਤਰ ਵਿੱਚ ਸੰਸਾਧਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਫਾਈਲ ਅੱਪਲੋਡ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।
9. ਮੈਂ Django ਵਿੱਚ ਚਿੱਤਰ ਅੱਪਲੋਡਾਂ ਦੀ ਜਾਂਚ ਕਿਵੇਂ ਕਰਾਂ?
10. ਤੁਸੀਂ Django ਦੇ ਟੈਸਟਿੰਗ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਫਾਈਲ ਅਪਲੋਡਾਂ ਦੀ ਨਕਲ ਕਰਨ ਅਤੇ ਬੈਕਐਂਡ ਤਰਕ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ।

Django ਵਿੱਚ AJAX ਦੁਆਰਾ ਚਿੱਤਰ ਅੱਪਲੋਡਾਂ ਨੂੰ ਸੰਭਾਲਣ ਵੇਲੇ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਫਰੰਟਐਂਡ ਚਿੱਤਰ ਨੂੰ ਫਾਰਮ ਡੇਟਾ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਸਹੀ ਢੰਗ ਨਾਲ ਪ੍ਰਸਾਰਿਤ ਕਰਦਾ ਹੈ। ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਗੁੰਮ ਚਿੱਤਰਾਂ ਦੇ ਮੁੱਦੇ ਨੂੰ ਹੱਲ ਕਰਦੇ ਹੋਏ, ਸਟ੍ਰਿੰਗਾਂ ਵਿੱਚ ਪਰਿਵਰਤਿਤ ਕੀਤੇ ਬਿਨਾਂ ਫਾਈਲਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਭੇਜਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

ਬੈਕਐਂਡ 'ਤੇ, Django's ਅਪਲੋਡ ਕੀਤੀ ਫਾਈਲ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਡੀਬਗਿੰਗ ਜ਼ਰੂਰੀ ਹੈ, ਅਤੇ ਫਾਈਲ ਹੈਂਡਲਿੰਗ ਪ੍ਰਕਿਰਿਆ 'ਤੇ ਧਿਆਨ ਨਾਲ ਧਿਆਨ ਦੇਣ ਨਾਲ ਜ਼ਿਆਦਾਤਰ ਗਲਤੀਆਂ ਨੂੰ ਹੱਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ 400 ਗਲਤੀਆਂ ਦੇ ਬਿਨਾਂ ਉਮੀਦ ਅਨੁਸਾਰ ਚਿੱਤਰ ਅੱਪਲੋਡ ਅਤੇ ਪ੍ਰੋਸੈਸਿੰਗ ਕੰਮ ਹੋ ਸਕਦਾ ਹੈ।