--- title: "Creat seiceála an chórais" version: 5.2 locale: ga source: https://docs.djangoproject.com/ga/5.2/topics/checks/ canonical: https://djangodocs.dev/ga/5.2/topics/checks/ --- # Creat seiceála an chórais Is sraith seiceálacha statacha é creat seiceála an chórais chun tionscadail Django a bhailíochtú. Braithíonn sé fadhbanna coitianta agus soláthraíonn sé leideanna maidir le conas iad a shocrú. Tá an creat inleathnaithe ionas gur féidir leat do sheiceálacha féin a chur leis go héasca. Is féidir seiceálacha a spreagadh go sainráite tríd an ordú:djadmin: check. Cuirtear seiceálacha a spreagadh go hiontach roimh fhormhór na n-orduithe, lena n-áirítear: djadmin: runserver agus:djadmin: migrate. Ar chúiseanna feidhmíochta, ní reáchtáiltear seiceálacha mar chuid den chruach WSGI a úsáidtear in imscaradh. Más gá duit seiceálacha córais a reáchtáil ar do fhreastalaí imscartha, spreag iad go sainráite ag baint úsáide as: djadmin: check. Cuirfidh earráidí tromchúiseacha cosc ar orduithe Django (mar shampla: djadmin: runserver) ó rith ar chor ar bith. Tuairiscítear mionfhadhbanna don chonsól. Má rinne tú iniúchadh ar chúis rabhaidh agus má tá tú sásta neamhaird a dhéanamh air, is féidir leat rabhaidh sonracha a cheilt ag baint úsáide as an socrú: setting: SILENCED\_SYSTEM\_CHECKS i do chomhad socruithe tionscadail. Is féidir liosta iomlán de na seiceálacha go léir is féidir le Django a ardú a fháil in:doc: Tagairt seiceála córas \. ## Do sheiceálacha féin a scríobh Tá an creat solúbtha agus tugann sé deis duit feidhmeanna a scríobh a dhéanann aon chineál eile seiceála a d'fhéadfadh a bheith ag teastáil uait. Seo a leanas feidhm sheiceála stub sampla: ``` from django.core.checks import Error, register @register() def example_check(app_configs, **kwargs): errors = [] # ... your check logic here if check_failed: errors.append( Error( "an error", hint="A hint.", obj=checked_object, id="myapp.E001", ) ) return errors ``` Caithfidh an fheidhm seiceála\* glacadh le hargóint `app_configs`; is é an argóint seo an liosta d'iarratais ar chóir a iniúchadh. Má tá None , ní mór an seiceáil a reáchtáil ar\* gach aipeanna suiteáilte sa tionscadal. Gheobhaidh an seic argóint eochairfhocal ````bunachar sonraí ``. Is liosta é seo d'ainmneacha bunachar sonraí ar féidir a naisc a úsáid chun cumraíocht leibhéal bunachar sonraí a iniúchadh. Más é ```bunachar sonraí ``None````, ní mór don seiceáil aon naisc bunachar sonraí a úsáid. Tá an argóint kwargs ag teastáil le haghaidh leathnú amach anseo. ### Teachtaireachtaí Caithfidh an fheidhm liosta teachtaireachtaí a thabhairt ar ais. Mura bhfaightear aon fhadhbanna mar thoradh ar an seiceáil, caithfidh an fheidhm seiceála liosta folamh a thabhairt ar ais. Caithfidh na rabhaidh agus na hearráidí arna ardú ag an modh seiceála a bheith ina gcásanna de:class: ~django.core.checks.checkMessage. Cuimsíonn sampla de:class: ~Django.Core.Checks.CheckMessage earráid nó rabhadh amháin a thuairiscithe. Soláthraíonn sé comhthéacs agus leideanna is infheidhme maidir leis an teachtaireacht, agus aitheantóir uathúil a úsáidtear chun críocha scagtha. Tá an coincheap an-chosúil le teachtaireachtaí óna:doc: creat teachtaireachtaí nó la:doc: creat logála \ \. Tá 'leibhéal' clibeáilte ag teachtaireachtaí a léiríonn déine na teachtaireachta. Tá aicearraí ann freisin chun teachtaireachtaí a chruthú le leibhéil choiteanna a dhéanamh níos éasca. Agus na ranganna seo á úsáid agat is féidir leat an argóint leibhéil a fhágáil toisc go bhfuil ainm an ranga intuigthe air. - [`Debug`](/ga/5.2/ref/checks/#django.core.checks.Debug) - [`Info`](/ga/5.2/ref/checks/#django.core.checks.Info) - [`Warning`](/ga/5.2/ref/checks/#django.core.checks.Warning) - [`Error`](/ga/5.2/ref/checks/#django.core.checks.Error) - [`Critical`](/ga/5.2/ref/checks/#django.core.checks.Critical) ### Seiceálacha clárú agus lipéad Ar deireadh, caithfear d'fheidhm seiceála a chlárú go sainráite le clárlann seiceála córais. \Ba chóir seiceálacha a chlárú i gcomhad a luchtaítear nuair a luchtaítear d'iarratas; mar shampla, sa modh:meth: AppConfig.ready () . #### `register(*tags)(function)` Is féidir leat an oiread clibeanna a chur chuig `clár` agus is mian leat d'fhonn do sheic a lipéadú. Tá seiceálacha clibeála úsáideach ós rud é go gceadaíonn sé duit ach grúpa áirithe seiceálacha a reáchtáil. Mar shampla, chun seiceáil comhoiriúnachta a chlárú, déanfá an glao seo a leanas: ``` from django.core.checks import register, Tags @register(Tags.compatibility) def my_check(app_configs, **kwargs): # ... perform compatibility checks and collect errors return errors ``` Is féidir leat “seiceálacha imscartha” a chlárú nach bhfuil ábhartha ach le comhad socruithe táirgeachta mar seo: ``` @register(Tags.security, deploy=True) def my_check(app_configs, **kwargs): ... ``` Ní reáchtálfar na seiceálacha seo ach amháin má úsáidtear an rogha: check --deploy. Is féidir leat `clár` a úsáid freisin mar fheidhm seachas maisitheoir trí réad inghlaonta (feidhm de ghnáth) a chur ar aghaidh mar an chéad argóint chun `clár`. Tá an cód thíos comhionann leis an gcód thuas: ``` def my_check(app_configs, **kwargs): ... register(my_check, Tags.security, deploy=True) ``` ### Seiceálacha réimse, samhail, bainisteoir, inneall teimpléad agus bunachar sonraí I roinnt cásanna, ní bheidh ort do fheidhm seiceála a chlárú - is féidir leat piggyback ar chlárú atá ann cheana. Cuireann réimsí, samhlacha, bainisteoirí samhlacha, innill teimpléid, agus cúltaca bunachar sonraí go léir modh seiceáil () i bhfeidhm atá cláraithe cheana leis an gcreat seiceála. Más mian leat seiceálacha breise a chur leis, is féidir leat an cur i bhfeidhm ar an rang bonn a leathnú, aon seiceálacha breise a theastaíonn uait a dhéanamh, agus aon teachtaireachtaí a chur leis na teachtaireachtaí a ghineann an bunaicme. Moltar duit gach seiceáil a tharmligean chuig modhanna ar leithligh. Smaoinigh ar shampla ina bhfuil réimse saincheaptha darb ainm `RangedIntegerField` á chur i bhfeidhm agat. Cuireann an réimse seo argóintí `min` agus `max` le tógálaí `IntegerField`. B'fhéidir gur mhaith leat seic a chur leis chun a chinntiú go soláthraíonn úsáideoirí luach íosta atá níos lú ná nó comhionann leis an luach uasta. Taispeánann an snippet cód seo a leanas conas is féidir leat an seiceáil seo a chur i bhfeidhm: ``` from django.core import checks from django.db import models class RangedIntegerField(models.IntegerField): def __init__(self, min=None, max=None, **kwargs): super().__init__(**kwargs) self.min = min self.max = max def check(self, **kwargs): # Call the superclass errors = super().check(**kwargs) # Do some custom checks and add messages to `errors`: errors.extend(self._check_min_max_values(**kwargs)) # Return all errors and warnings return errors def _check_min_max_values(self, **kwargs): if self.min is not None and self.max is not None and self.min > self.max: return [ checks.Error( "min greater than max.", hint="Decrease min or increase max.", obj=self, id="myapp.E001", ) ] # When no error, return an empty list return [] ``` Dá dteastaíonn uait seiceálacha a chur le bainisteoir samhail, glacfá an cur chuige céanna ar do fho-aicme de:class: ~Django.db.Models.Manager. Más mian leat seic a chur le rang samhail, is é an cur chuige beagnach mar an gcéanna: is é an t-aon difríocht ná gur modh ranga é an seiceáil, ní modh sampla: ``` class MyModel(models.Model): @classmethod def check(cls, **kwargs): errors = super().check(**kwargs) # ... your own checks ... return errors ``` > **Changed in Django 5.1** > > I leaganacha níos sine, níor chuir innill teimpléid modh check () i bhfeidhm. ### Tástála scríbhneo Tá teachtaireachtaí inchomparáide. Ligeann sé sin duit tástálacha a scríobh go héasca: ``` from django.core.checks import Error errors = checked_object.check() expected_errors = [ Error( "an error", hint="A hint.", obj=checked_object, id="myapp.E001", ) ] self.assertEqual(errors, expected_errors) ``` #### Tástálacha comhtháthaithe a Mar gheall ar an ngá atá le seiceálacha áirithe a chlárú nuair a luchtaíonn an feidhmchlár, d'fhéadfadh sé a bheith úsáideach a gcomhtháthú a thástáil laistigh Is féidir é seo a chur i gcrích tríd an bhfeidhm: func: ~django.core.management.call\_command a úsáid. \Mar shampla, léiríonn an tástáil seo go gcaithfidh an socrúit:setting: SITE\_ID a bheith ina sláimhir, ina ion:ref: seiceáil ó chreat na suíomhanna : ``` from django.core.management import call_command from django.core.management.base import SystemCheckError from django.test import SimpleTestCase, modify_settings, override_settings class SystemCheckIntegrationTest(SimpleTestCase): @override_settings(SITE_ID="non_integer") @modify_settings(INSTALLED_APPS={"prepend": "django.contrib.sites"}) def test_non_integer_site_id(self): message = "(sites.E101) The SITE_ID setting must be an integer." with self.assertRaisesMessage(SystemCheckError, message): call_command("check") ``` Smaoinigh ar an seiceáil seo a leanas a eisíonn rabhadh maidir le himscaradh mura bhfuil socrú saincheaptha darb ainm ENABLE\_ANALYTICS\` socraithe go `True`: ``` from django.conf import settings from django.core.checks import Warning, register @register("myapp", deploy=True) def check_enable_analytics_is_true_on_deploy(app_configs, **kwargs): errors = [] if getattr(settings, "ENABLE_ANALYTICS", None) is not True: errors.append( Warning( "The ENABLE_ANALYTICS setting should be set to True in deployment.", id="myapp.W001", ) ) return errors ``` Ós rud é nach n-ardóidh an seiceáil seo SystemCheckerror\`, is féidir láithreacht na teachtaireachta rabhaidh san aschur `stderr` a dhearbhú mar seo: ``` from io import StringIO from django.core.management import call_command from django.test import SimpleTestCase, override_settings class EnableAnalyticsDeploymentCheckTest(SimpleTestCase): @override_settings(ENABLE_ANALYTICS=None) def test_when_set_to_none(self): stderr = StringIO() call_command("check", "-t", "myapp", "--deploy", stderr=stderr) message = ( "(myapp.W001) The ENABLE_ANALYTICS setting should be set " "to True in deployment." ) self.assertIn(message, stderr.getvalue()) ```