Veloce. Directory subordinate. Velocemente Come creare una directory subordinata 1c

Klyuev V.V.

http://prof1c.kklab.ru

Directory subordinate

Molto probabilmente, hai già notato più volte nelle normali configurazioni tipiche che le directory sono interconnesse, quando quando si seleziona un elemento della directory (directory 1), il valore di un'altra directory (directory 2) viene "filtrato" da questo valore, ovvero i valori ​​che appartengono solo all'elemento della directory corrente vengono selezionati; ad esempio, questa è la directory "Divisione", il cui proprietario è la directory "Organizzazione".

Per comprendere immediatamente l'essenza di ciò che sta accadendo, diamo un'occhiata a cosa succede nella pratica. Per fare ciò, puoi creare una configurazione vuota da zero, oppure andare su qualsiasi copia esistente dell'infobase e creare 2 directory nel configuratore.

Directory1 e Directory2. Nella directory2, vai alla scheda "Proprietari" e seleziona il proprietario - "Directory1", vedi come mostrato nella figura.

Ora, durante la creazione di elementi nella “Directory2”, il sistema ti chiederà di inserire il proprietario della directory1. Esiste un'opzione - Usa subordinazione - quando la subordinazione è impostata su Elementi, gruppi o gruppi ed elementi.

Sembrerebbe che tutto sia semplice, ma sorgono problemi per gli utenti. Aprendo la "Directory 2", l'utente vede tutti gli elementi in un ordine del tutto incomprensibile e inoltre, se hai lavorato con configurazioni standard, potresti aver notato che direttamente nella directory "Divisioni" non specifichi il proprietario da nessuna parte, ma aprendo la directory è possibile selezionare l'organizzazione e, a seconda di questa, ricevere elementi subordinati all'una o all'altra organizzazione; Inoltre, quando crei la voce della directory "Divisioni", per impostazione predefinita riceverai il proprietario che hai selezionato sotto forma di elenco delle divisioni.
Quindi iniziamo e creiamo un "Modulo elenco" per la nostra "Directory2", per ora forniscilo a 1C senza apportare modifiche, in seguito adegueremo il modulo creato dal designer.
In "Directory2" vai alla scheda Moduli e aggiungi (+) un nuovo modulo Elenco directory e fai clic su Fine.

Creiamo un attributo del modulo con il tipo di dati "Directory1.Link", con il nome "SelectionDirectory1", e trasciniamo questo attributo sul modulo, impostiamo il titolo "Directory1".


Ora, affinché "questo miracolo" funzioni, è necessario scrivere il codice che effettuerà una selezione quando si seleziona un Directory Element1.

8.2, 8.3 Moduli gestiti

Per poter visualizzare sotto forma di elenco di directory solo gli elementi di cui abbiamo bisogno per l'elemento selezionato di Directory1, dobbiamo effettuare a livello di codice una selezione in base all'elemento selezionato, per fare ciò utilizzeremo la procedura predefinita del controllo SelectionDirectory1 e scrivere il codice che esegue l'attività specificata.
In alto, seleziona “Selection Directory1”, fai clic con il tasto destro e seleziona “Proprietà”, nella finestra che appare, trova la proprietà “OnChange” e fai clic sulla lente di ingrandimento, andando così al modulo del modulo; viene creata automaticamente la procedura “Selezione Directory1SuCambia(Elemento)”.

Nella procedura inserire il seguente testo:

& Nell'elenco Directory1OnChange(Element) di selezione della procedura client. Selezione. Elementi. Chiaro() ; // Elemento di selezione = Elenco. Selezione. Elementi. Aggiungi(Tipo(" Layout dei dati degli elementi di selezione" ) ); Elemento di selezione. LeftValue = Nuovo campo DataComposition (" Proprietario " ); Elemento di selezione. Visualizzazione confronto = Visualizzazione confronto composizione dati. Uguale a; Elemento di selezione. Utilizzo = True ; Elemento di selezione. RightValue = Directory di selezione1; Elemento di selezione. DisplayMode = DisplayModeElement aDataCompositionSettings.Unavailable;EndProcedure

8.2 Forme regolari


Quando si creano moduli, tutto è uguale, solo i moduli devono essere creati come normali; i moduli gestiti non funzionano in un'applicazione normale.
La differenza sarà nella procedura di selezione dell'elemento nella scheda lista e nella creazione degli oggetti di scena.
Per aggiungere dettagli a un modulo normale, fare clic sul pulsante

Riferimento alla procedura1OnChange(Element)ThisForm. Selezione. Proprietario. Valore = Directory1. Collegamento; Questa forma. Selezione. Proprietario. Utilizzo = Vero; Questa forma. Elementi del modulo. Elenco directory. Impostazioni di selezione. Proprietario. Disponibilità = Falso; //(?) Fine della procedura

La penultima riga(?) - proibiamo di modificare la selezione quando l'utente apre i parametri di selezione - solo attraverso l'elemento di controllo!

Video (senza audio: tutto è chiaro senza audio)

Cosa sono le directory 1C e quale ruolo svolgono in 1C - su questo e molto altro nel nostro nuovo articolo.

Le directory in 1C vengono create per archiviare informazioni che verranno utilizzate per lavorare in altri documenti in 1C, ad esempio i report. Si scopre che il lavoro nel sistema 1C viene svolto secondo i libri di consultazione e tutte le informazioni in essi archiviate sono chiamate normative e riferimenti.

A cosa servono le directory 1C?

Qualsiasi prodotto servirà da chiaro esempio di spiegazione. Per la sua movimentazione all'interno dell'impresa (acquisto, stoccaggio in magazzino, installazione, vendita, ecc.), vengono redatti documenti speciali, ad esempio moduli, fatture, ecc. In una situazione normale, tutti questi documenti verrebbero compilati manualmente, ma se viene utilizzato un sistema automatizzato, ciò non solo farà risparmiare tempo, ma eviterà anche che si verifichino molti errori.

Un sistema automatizzato ti consente di creare una volta una lista, che poi include proprio questo prodotto. Se necessario, puoi sempre indicare nella descrizione i dati necessari, le caratteristiche e le altre informazioni. Si scopre che le directory 1C sono elenchi già pronti con dati su prodotti, clienti, servizi, ecc. Se necessario, gli elenchi possono essere modificati e integrati.

Dove si trovano le directory 1C?

In genere, l'interfaccia per lavorare in 1C Enterprise è sviluppata da un programmatore, il che significa che directory diverse possono trovarsi in menu completamente diversi.

Nel Thick Client, un utente con diritti di amministratore è in grado di aprire qualsiasi documento 1C e ha accesso a qualsiasi directory. Per fare ciò, devi aprire il menu “operazioni”, fare clic su “directory” e selezionare quella che ti serve dall'elenco fornito.


Se guardi nel thin client, c'è anche un menu simile. Si chiama "tutte le funzioni". In termini di funzionamento, è simile al menu “operazioni”.

Nella modalità configuratore, l'accesso a tutte le directory è disponibile attraverso il ramo di configurazione. Da lì puoi lavorare con qualsiasi directory, personalizzarne il modello, modificarlo e così via. Per iniziare, fai doppio clic su di esso con il mouse.

Che tipo di directory 1C assomigliano?

Quando apri la directory 1C 8, davanti a te si apre un modulo sotto forma di elenco. Per comodità, gli elenchi possono essere raggruppati in base a determinate caratteristiche e caratteristiche.


Quando apri un gruppo, davanti a te appare un elenco di tutti gli elementi. E dopo aver cliccato sull'elemento stesso, sarà disponibile un modulo di directory, i cui campi possono essere compilati e modificati.

Molto spesso in 1C Enterprise ci sono due campi obbligatori per le directory:

    Nome della directory.

Sono progettati per aiutare a distinguere un elemento da un altro. A volte i programmatori disabilitano queste opzioni, ma ciò accade estremamente raramente.


Il campo "codice" viene spesso chiuso alla modifica da parte degli utenti (sono richiesti diritti di accesso speciali) e il suo valore viene generato automaticamente.

La nomenclatura in 1C 8.3 significa materiali, semilavorati, attrezzature, servizi, imballaggi restituibili, indumenti da lavoro, ecc. Tutti questi dati sono archiviati nella directory Nomenclatura. È possibile accedervi dalla sezione “Elenchi”, sottosezione “Beni e servizi”, voce “Nomenclatura”

Vedrai un elenco di posizioni della directory che ha una struttura gerarchica a più livelli.

In questo articolo esamineremo passo dopo passo tutte le istruzioni per la compilazione iniziale degli elementi in 1C 8.3 utilizzando un esempio

Per facilità d'uso di questo libro di consultazione, 1C Accounting utilizza gruppi (cartelle). Combinano una nomenclatura che ha caratteristiche comuni. In ogni gruppo è possibile creare a loro volta dei sottogruppi (simili al file system di un computer). Il numero di livelli gerarchici è stabilito dal programmatore, ma inizialmente non ci sono restrizioni.

Creiamo un nuovo gruppo. Nel modulo elenco della directory “Nomenclatura”, fare clic sul pulsante “Crea gruppo”.

Specificare il nome del gruppo da creare. Puoi anche inserirne il tipo, ma non è necessario.

Come puoi vedere nella figura qui sotto, il gruppo che abbiamo creato è stato inserito in “Materiali”. Se devi spostarlo in un altro gruppo o nella radice, apri il menu contestuale e seleziona "Sposta nel gruppo". Si aprirà una finestra in cui dovrai specificare una nuova posizione.

Creazione di un nuovo elemento

Passiamo all'aggiunta della nomenclatura stessa. Per fare ciò, nel modulo dell'elenco delle directory, fare clic sul pulsante "Crea". Una scheda del nuovo articolo si aprirà davanti a te.

Compila il campo "Nome". Il valore nel campo "Nome completo" verrà inserito automaticamente. Tieni presente che il nome completo viene visualizzato nei rapporti, nei moduli stampati dei documenti, nei cartellini dei prezzi, ecc. Il campo "Nome" viene utilizzato per una comoda ricerca degli articoli nel programma.

Se necessario, inserisci i restanti dettagli:

  • I campi “Tipo articolo” e “Incluso nel gruppo” vengono compilati automaticamente a partire dai dati del gruppo in cui viene creato il nuovo articolo articolo. Possono essere modificati se necessario.
  • Il valore nel campo “Unità” è l'unità di stoccaggio per i saldi di questa voce.
  • L'aliquota fiscale specificata nel dettaglio “% IVA” può, se necessario, essere modificata durante la generazione dei documenti.
  • Il "Prezzo di vendita" è indicato di default sui documenti di vendita. Questa impostazione può essere modificata facendo clic sul collegamento ipertestuale “?” accanto a questo campo.
  • Nella sezione “Produzione” è possibile indicare la voce di costo di un determinato articolo e la sua specificazione (per i prodotti finiti), ovvero la composizione.
  • A seconda delle specificità della nomenclatura, vengono compilate le sezioni rimanenti, come "Prodotti alcolici" e "Merci importate".

Dopo aver compilato la scheda per l'oggetto che stai creando, devi annotarla.

Qual è il tipo di elemento in 1C 8.3 e come configurarli

Per configurare i tipi di nomenclatura, fare clic sul collegamento ipertestuale corrispondente nel modulo elenco della directory “Nomenclatura”.

I tipi di nomenclatura sono necessari per separare gli articoli. A ogni tipo può essere assegnato il proprio. È molto importante evitare la presenza di duplicati in questa directory, il che può portare a un funzionamento errato dei conti contabili delle posizioni.

Quando si installa una configurazione standard del fornitore, questa directory sarà già compilata con le principali tipologie di articoli. Se la tipologia dell'articolo è un servizio, non dimenticare di mettere l'apposito flag al momento della creazione.

Conti contabili delle voci in 1C 8.3

Per generare voci contabili è necessario impostare i conti contabili. Ciò può essere fatto dal modulo elenco della directory "Nomenclatura" facendo clic sul collegamento ipertestuale "Conti contabilità articoli".

Nella configurazione standard di 1C Accounting 3.0, questo registro è già compilato. Ma se necessario, può essere regolato manualmente.

È possibile configurare i conti contabili:

  • secondo una specifica voce della nomenclatura;
  • per gruppo di nomenclatura;
  • per tipo di nomenclatura;
  • per magazzino;
  • per tipologia di magazzino;
  • per organizzazione;
  • in tutta la nomenclatura, specificando un collegamento vuoto come valore.

Se per un articolo specifico e per esso sono stati configurati conti contabili diversi, il conto verrà prelevato dall'articolo. In questi casi, i conti consolidati hanno una priorità inferiore.

Impostazione dei prezzi degli articoli

Un articolo può avere diversi prezzi. Differiscono in tipologie, come prezzo all'ingrosso, prezzo al dettaglio, ecc.

Vai alla scheda dell'elemento della directory "Nomenclatura" e segui il collegamento ipertestuale "Prezzi".

Di fronte a te si aprirà un elenco in cui puoi scegliere un tipo specifico in una data specifica. È sufficiente indicare il prezzo nell'apposita colonna e poi cliccare sul pulsante “Registra prezzi”. Un documento di impostazione del prezzo dell'articolo verrà creato automaticamente e vedrai un collegamento ad esso in questo elenco.

Guarda anche il video sulla nomenclatura:

Ospedale psichiatrico. Un idiota all'altro:
-Ti è piaciuta la mia storia che ti ho dato da leggere ieri?
-Sì, ma in qualche modo tutto è sfocato e ci sono molti personaggi.
Il medico entra:
-Allora, idioti, chi mi ha rubato l'elenco telefonico?...

Scopo delle directory
La directory è un elenco di possibili valori di un particolare attributo. Le directory vengono utilizzate nei casi in cui è necessario eliminare l'immissione di informazioni ambigue.Ad esempio, affinché l'acquirente, il venditore, il negoziante, il direttore capiscano di quale prodotto stiamo parlando, tutti devono chiamarlo uguale. E in questo caso è necessario un libro di consultazione. Di solito in una società commerciale ha la forma di un listino prezzi e, se tale directory è archiviata su un computer, viene inserita l'intera gamma possibile di beni con cui lavora la società commerciale.

Il sistema 1C:Enterprise ti consente di mantenere un numero quasi illimitato di directory necessarie. Ogni directory è un elenco di oggetti omogenei: dipendenti, organizzazioni, beni, ecc. Ciascuno di questi oggetti viene chiamato elemento della directory.

Dal punto di vista dell'utente, va tenuto presente che nel Configuratore non viene creata la directory stessa come elenco di valori, ma viene sviluppato un modello per la directory, il suo modello. Durante il processo di configurazione viene descritta la struttura delle informazioni che verranno archiviate nella directory, viene sviluppata una rappresentazione su schermo e, se necessario, stampata della directory e vengono specificate varie caratteristiche del suo "comportamento".

Attributi della directory

Come dettagli obbligatori, ogni directory ha Codice E Nome. Il codice dell'elemento della directory può essere numerico o testuale. Il sistema 1C:Enterprise offre ampie opportunità per lavorare con i codici degli elementi della directory: assegnazione automatica dei codici, controllo automatico dell'unicità del codice e altro.

Oltre al codice e al nome, qualsiasi informazione aggiuntiva su un elemento della directory può essere memorizzata nelle directory di sistema 1C:Enterprise. Per memorizzare tali informazioni nella directory, è possibile creare un elenco dettagli. Utilizzando il meccanismo dei dettagli della directory, è facile organizzare, ad esempio, il file di un dipendente.Ad esempio, una directory Dipendenti avrà quasi certamente gli attributi Titolo di lavoro, Stipendio e altri.La società 1C ha anticipato i programmatori e ha introdotto tutti i libri di consultazione due attributi già definiti: Codice E Nome. In effetti, quasi tutti gli oggetti della vita reale contengono questi attributi. Ad esempio, per i dipendenti il ​​codice è il numero del personale e il nome è il cognome, nome, patronimico (nome completo).

Tipi di dati

Per ogni attributo della directory è necessario specificarne il tipo di dati, ad esempio " numero", "linea", "data"(nella versione 8.0 esiste anche un tipo booleano: True o False). Questi sono tipi di base, ma puoi anche specificare tipi di dati complessi. Ad esempio, un attributo Titolo di lavoro ha un tipo di dati Posizioni. In questo caso, i valori di questo attributo verranno selezionati dalla directory Posizioni. In questo modo viene realizzata la connessione più semplice tra directory, quando i valori degli attributi di una directory vengono selezionati da un'altra directory.

Directory gerarchiche

L'elenco degli elementi della directory nel sistema 1C:Enterprise può essere multilivello. In questo caso, tutte le linee della directory saranno divise in 2 tipi: "solo" elementi della directory e gruppi libro di consultazione. I gruppi consentono di spostarsi ai livelli inferiori di una directory a più livelli. L'uso di directory multilivello consente di organizzare l'immissione delle informazioni nella directory con il livello di dettaglio richiesto. Elementi e gruppi di elementi in una directory a più livelli possono essere trasferiti da un gruppo all'altro.

Directory subordinate

È possibile stabilire una relazione tra le directory subordinazione. In termini di database relazionale, viene stabilita una relazione uno-a-molti tra le tabelle. In questo caso, ogni elemento della directory subordinata sarà associato a uno degli elementi della directory proprietaria. A volte possiamo dire che gli elementi di una directory appartenere elementi di un altro. Ad esempio, il sistema potrebbe disporre di una directory sui benefici fiscali. Allora si può fare subordinati Dipendenti dell'elenco. Significa che "Il dipendente gode di vantaggi fiscali".

Direttorio Dipendenti

Direttorio Prestazioni fiscali

  • Ivanov Ivanov Ivanov
  • Petrov Petr Petrovich
  • Svetlov Michail Petrovich
  • Tsvetkov Anton Vasilievich

( proprietario Petrov Petr Petrovich)

  • Vantaggi per i veterani
  • Vantaggio per i bambini
  • Ivanov Ivanov Ivanov
  • Petrov Petr Petrovich
  • Svetlov Michail Petrovich
  • Tsvetkov Anton Vasilievich

( proprietario Svetlov Michail Petrovich)

  • Vantaggio per gli afghani

Parti della tabella (solo versione 8.0)

Nella versione 8.0 è diventato possibile che un elemento di directory abbia più parti tabulari. Si consiglia di utilizzare questa funzionalità per riflettere le informazioni relative ad un dato elemento, ma che non ha una propria entità oggetto (per la quale si consiglia di creare una directory subordinata). Ad esempio, per riferimento Per i Prodotti è possibile creare la sezione tabellare Unità di Misura; per l'elenco Dipendenti è possibile creare le sezioni tabellari Istruzione e Composizione familiare. Lavorare con le parti tabulari è simile a lavorare con le directory subordinate, tranne per il fatto che le parti tabulari non possono essere tipi, il che significa che non sarà più possibile creare un attributo di tipo Education.

Confronto di directory con altri oggetti

Un oggetto

Analogie

Differenze

Costanti memorizza il valore, salvato nel database La directory memorizza non solo un valore, ma un intero elenco di oggetti omogenei.
Documentazione salvato nel database, ha dettagli, i documenti possono essere subordinati l'uno all'altro La directory memorizza informazioni normative e di riferimento e i documenti riflettono eventi del mondo reale. In genere, i valori dei dettagli del documento vengono selezionati dalle directory. Il documento viene solitamente pubblicato, il documento deve avere una data e un'ora, il documento può contenere una parte tabellare, che non si trova nelle directory (nella versione 8.0, directory e documenti possono avere più parti tabellari). Le directory possono essere multi-livello; la directory può contenere dettagli periodici, che non sono presenti nei documenti (nella versione 8.0 non ci sono dettagli periodici, ma sono presenti registri periodici delle informazioni).
Trasferimenti memorizzato nel database, memorizza un elenco di valori L'utente inserisce un insieme di valori nella directory in modalità Enterprise e per le enumerazioni l'elenco dei valori viene specificato dallo sviluppatore in modalità Configuratore. Le enumerazioni sono comunemente utilizzate nelle istruzioni If.
Tabella dei valori ha righe e colonne (non memorizzate nel database) La tabella valori è progettata per archiviare dati intermedi nella memoria del computer che si verificano durante il funzionamento del programma. Una tabella di valori può memorizzare oggetti eterogenei, mentre una directory può memorizzare tutti gli elementi dello stesso tipo. Le tabelle dei valori non possono essere multilivello o subordinate l'una all'altra.
ElencoValori memorizza un elenco di valori (non salvato nel database) Un elenco di valori può memorizzare oggetti eterogenei e in una directory tutti gli elementi dello stesso tipo

Nozioni di base sulla programmazione

Creazione e registrazione di un nuovo elemento

Trovare un elemento della directory


//ad esempio, in un ordine di licenziamento
Rif. TrovaElemento(Dipendente);

Rif. Trova per codice(123);
Rif. Trova per nome("Ivanov Ivan Ivanovich");
Rif. Trova per dettagli("Stipendio", 5000);

//se l'elemento viene trovato, diventa quello corrente e può essere letto così:

Se Spr.FindByName("Ivanov Ivan Ivanovich") = 1 Allora
........CotrTrovato = CotrRif. Elemento corrente();
finisci se;


//nella versione 8.0, se l'elemento viene trovato, viene restituito, altrimenti viene restituito Indefinito

CotrTrovato = CotrRif. Trova per codice(123);
CotrTrovato = CotrRif. Trova per nome("Ivanov Ivan Ivanovich");
CotrTrovato CotrRif. Trova per dettagli("Stipendio", 5000);

FoundSotr = SprSotr.FindByName("Ivanov Ivan Ivanovich");
Se FoundSotr = Non definito Allora
.....//elemento non trovato
finisci se;

Eliminazione di un elemento di directory

Rif. Eliminare(1); //cancellazione immediata

Rif. Eliminare(0); //contrassegna per la cancellazione
Rif. Deseleziona Elimina();


Marchio = Rif. FlagEliminazione(); //nota: questo è un metodo


Rif. Eliminare(); //cancellazione immediata

Rif. SetDeleteMark (Vero); // contrassegnare per la cancellazione
Rif. SetDeletionMark (Falso); //decollare contrassegnare per la cancellazione

//puoi controllare se un elemento è contrassegnato per l'eliminazione
//c'è una proprietà MarkDelete, è di tipo Booleano - True o False

Marchio = Rif. FlagEliminazione; //nota: questa è una proprietà
Se Mark = True Allora
.....//elemento contrassegnato per l'eliminazione
finisci se;

Enumerazione degli elementi della directory


Rif. Seleziona elementi();
Mentre SprSotr. OttieniElemento() = 1 ciclo
...
...Notifica("Dipendente" + Nome dipendente);
FineCiclo;


selezione = Directory.Dipendenti. Scegliere();
Solo una selezione per ora. Prossimo() = 1 ciclo
... //azioni con l'elemento successivo
FineCiclo;


Genitore
Itera sugli elementi all'interno di un gruppo. Un gruppo in termini 1C è un “genitore”.


Rif.FindByName("Funzionante");
Funzionante = Ref.CurrentItem();
Rif. UsaParent(Lavorando);
//ulteriore, ad esempio, un ciclo per i dipendenti (vedi sopra)
...



GroupWorking = SprSotr.FindByName("Funzionante");
selezione = Rif. Scegliere(Lavoro di gruppo);
Solo una selezione per ora. Prossimo() = 1 ciclo
... //azioni con l'elemento successivo
...Notifica("Dipendente" + selezione.Nome);
FineCiclo;

Proprietario
Enumerazione degli elementi di directory appartenenti a un elemento di un'altra directory.
Un libro di riferimento subordinare un altro libro di consultazione, ad esempio libro di consultazione. I benefici fiscali sono soggetti al rif. Dipendenti.

Dettagli periodici
Leggere e scrivere dettagli periodici.
Impostazione della data per il campionamento dei dettagli periodici per l'intera directory.


//così scopriamo cosa aveva il dipendente
//categoria per una data specifica

Categoria = SprSotr.Categoria. Ottenere(Qualche data);

//questo è il modo in cui imposteremo la categoria per il dipendente
//per una data specifica
Categoria ordinamento rif. Installare(Qualche data, Nuova categoria);

//è possibile impostare la data di campionamento periodica
//dettagli per l'intera directory
Rif. UsaData(Qualche data);

//allora non potrai più utilizzare Installa e Ottieni di seguito
//l'accesso ai dettagli periodici diventa
//come per i dettagli normali
Categoria = SprSotr.Categoria;
Stipendio iniziale = 6000;

Nella versione 8.0 non sono presenti dettagli periodici. È necessario, invece, utilizzare registri informativi ampliati nel tempo.

Forme schermate di libri di consultazione

Modulo elenco elenchi

Per facilitare agli utenti il ​​lavoro con la directory in fase di configurazione, è possibile creare diversi tipi moduli dello schermo per visualizzare la directory. A seconda del contesto in cui si richiama la directory, è possibile specificare l'uso di una finestra di dialogo specifica per lavorare con essa.

È meglio vedere una volta che ascoltare cento volte, quindi di seguito è riportato un esempio di modulo di elenco per la directory Dipendenti:




Il modulo del modulo elenco contiene procedure e funzioni che operano nel contesto di questo modulo (nel contesto dell'oggetto Directory).

Procedure predefinite vengono chiamati dal sistema 1C al verificarsi di determinati eventi. Le procedure predefinite vengono chiamate dal sistema 1C quando si verificano determinati eventi, quindi sono gestori di eventi. Nella versione 8.0, il nome della procedura può essere qualsiasi cosa, non necessariamente uguale al nome dell'evento. Inoltre nella versione 8.0 l'elenco degli eventi per tutti gli oggetti è stato notevolmente ampliato.

Evento

Descrizione

All'apertura Chiamato quando viene aperto il modulo dell'elenco delle directory. È possibile impostare i valori iniziali per le variabili, verificare i diritti dell'utente per aprire questa directory, ecc.
In chiusura Chiamato quando il modulo dell'elenco delle directory è chiuso.
Durante la registrazione

Chiamato durante la scrittura di un elemento di directory, se gli elementi vengono immessi direttamente nel modulo elenco e non nel modulo elemento. Viene utilizzato per le directory con una struttura semplice, ad esempio la directory Jobs. Questa procedura consente di verificare la presenza di errori nei dati immessi.

Esempio, Posizioni della directory

Quando si seleziona il genitore (Nuovo genitore) Chiamato quando viene selezionato un genitore (gruppo). Utilizzare questa procedura per verificare i diritti di un utente per visualizzare i membri di un determinato gruppo.
Quando si seleziona il proprietario (nuovo proprietario) Chiamato quando viene selezionato il proprietario della directory host. Ha senso se questa directory è subordinata a un'altra.
QuandoImpostaSelezione(Attributi,Valore) Una procedura predefinita per impostare in modo interattivo la selezione in qualsiasi modo (selezione, selezione rapida, selezione per valore, cronologia della selezione) e per disabilitare la selezione.
SuRigaSeleziona() La modalità di elaborazione della selezione della riga (doppio clic o tasto Invio) è abilitata sotto forma di elenco di directory, giornale di registrazione documenti, conti, giornale di registrazione delle transazioni, giornale di registrazione delle transazioni utilizzando il metodo Form.RowSelectionProcessing(1). Quindi, quando viene selezionata una riga, verrà richiamata questa procedura predefinita.


Ordinamento

Sotto forma di elenco di directory, gli elementi possono essere ordinati in diversi ordini: per codice, per nome o per qualsiasi attributo per cui è selezionata la casella di controllo Ordinamento nel Configuratore.È possibile impostare il tipo di ordinamento a livello di codice utilizzando il metodo di ordinamento (metodo, flag ChangePermission)


Procedura SuApertura()
...... Ordinamento("Codice",0); //ordinamento per codice, l'utente non può modificare
Fine della procedura

Procedura SuApertura()
......DirectoryList.Order.Set("Nome Asc, Scheda Asc");
......//domanda ai lettori: come evitare che l'utente modifichi l'ordinamento?
Fine della procedura

Selezione

Nel modulo dell'elenco delle directory, gli elementi possono essere filtrati, ad es. All'utente verranno mostrati solo gli elementi necessari. È possibile impostare la selezione a livello di codice utilizzando il metodo SetSelection (Attributi, Valore). Per fare ciò, l'attributo deve avere la casella di controllo "Selezione per attributo" selezionata nel Configuratore .

Filtro statico (solo versione 7.7)

In 1C 7.7 non è possibile impostare la selezione per dettagli periodici o per più dettagli contemporaneamente (filtro complesso). In questo caso, il metodo UseList of Elements potrebbe essere una soluzione. A questo metodo deve essere passato un elenco di elementi che dovrebbero essere mostrati. Questo elenco deve essere creato prima.

Procedura ShowWorkingCarpenters()

ListaElementi = createObject("ListaValori");

Rif.SelectItems();

.....Se (Avv.Genitore = gruppoLavoro) AND (Avv.Posizione = lavoro Falegname) Allora
..........Elenco degli elementi.AddValue(Ref.CurrentElement());
.....Finisci se;
FineCiclo;

UsaElementiLista(Elementi della lista);

Fine della procedura

Forma dell'elemento e forma del gruppo

Se la directory ha una struttura complessa, è più conveniente modificarne gli elementi in una finestra separata anziché in un elenco. Di seguito è riportato il formato dell'elemento della directory Employees.


Il modulo dell'elemento directory ha anche procedure predefinite (eventi):

Eventi

Descrizione

All'apertura() Chiamato quando viene aperto il modulo dell'elemento di directory. Puoi impostare valori iniziali per le variabili, verificare i diritti dell'utente per aprire un determinato elemento della directory, ecc.
Alla chiusura() Chiamato quando il modulo dell'elemento del dizionario è chiuso.
OnWrite()

Chiamato quando viene scritto un elemento di directory. Questa procedura consente di verificare la presenza di errori nei dati immessi.

Esempio: directory Dipendenti

Procedura di registrazione
....Se Category.Selected()=0 Allora
.........Attenzione("Categoria dipendente non specificata!");
.........StatoRitorno(0);
.....Finisci se;
Fine della procedura

InvioNuovo() Chiamato quando un nuovo elemento di directory viene inserito in modo interattivo. In questa procedura è possibile verificare i diritti dell'utente per creare nuovi elementi della directory, nonché impostare i valori iniziali dei dettagli.

Va notato che nella versione 8.0 l'elenco degli eventi per tutti gli oggetti è stato notevolmente ampliato.

Creare e registrare un elemento

Creazione programmatica di un elemento di directory

Di seguito nella directory Employees, un nuovo dipendente viene aggiunto a livello di codice al gruppo di lavoro. Nella rubrica vengono compilati i campi Nome, Data di ricevimento e un paio di dettagli periodici.



Rif. Nuovo();


Rif. Scrivi();
//l'impostazione dei dettagli periodici è possibile solo dopo aver registrato l'elemento
Ref.Category.Set (Ref.ReceptionDate, ktgPartners);
Set.Posizione.Rif.(DataRicezioneRif., perCarpenter);

Ma puoi renderlo più bello:

RefCotr = CreateObject("Directory.Employees");
SprSotr.UseParent(grpWorking);
Ref.UseDate(ReceptionDate); //Attenzione!
Rif.Nuovo();
SprSotr.Name = "Ivanov Ivan Ivanovich";
Data di ricezione rif. = "01/01/2002";
//l'accesso ai dettagli periodici diventa lo stesso di quelli normali
SprSotr.Category = ktgPartners;
Posizione Spr = dljCarpentiere;
SprCotr.Write();

Nuovo = Directory.Employees.CreateItem();
New.Parent = groupWorking;
New.Name = "Ivanov Ivan Ivanovich";
New.ReceptionDate = "01/01/2002";
Nuovo.Scrivi();

//nella versione 8.0 non ci sono dettagli periodici

Creazione programmatica di gruppi

RefCotr = CreateObject("Directory.Employees");

Rif. Un nuovo gruppo();

Rif. Scrivi();

Rif.NuovoGruppo();

SprCotr.Write();

Nuovo = Directory.Dipendenti .Per creare un gruppo();

Nuovo Scrivi();

Nuovo = Directory["Dipendenti"] .Per creare un gruppo();
New.Name = "Lavoro";
Nuovo Scrivi();

Attenzione!

Transazioni

Quando crei molti elementi di directory, puoi racchiudere un ciclo in una transazione per accelerare il lavoro. In questo caso la creazione effettiva di tutti gli elementi avverrà solo con il comando CommitTransaction(). La directory è bloccata mentre la transazione è in esecuzione.

RefCotr = CreateObject("Directory.Employees");
Avvia transazione();

Per Nom = da 1 a 100 cicli
.....Rif.Nuovo();
.....SprSotr.Name = "Nuovo" + String(Nom);
.....RepCort.Write();
FineCiclo;

CommitTransaction();


SprSotr = Directory.Dipendenti;
Avvia transazione();

Per Nom = da 1 a 100 cicli
.....Nuovo = SprSotr.CreateElement();
.....Nuovo.Nome = "Nuovo" + String(Nom);
.....Nuovo.Scrivi();
FineCiclo;

CommitTransaction();

Iterazione sugli elementi

Ricerca semplice

RefCotr = CreateObject("Directory.Employees");
modalità = 0; //seleziona senza tenere conto della gerarchia, 1 - tenendo conto (per impostazione predefinita)
Rif. Seleziona elementi(Modalità);
Mentre SprSotr. OttieniElemento()=1 ciclo
.....<действия с очередным элементом/группой>
FineCiclo;

Filtrazione (selezione)

RefCotr = CreateObject("Directory.Employees");
Modalità gerarchia = 1; //1 - seleziona tenendo conto della gerarchia, 0 - senza tener conto
Modalità gruppo = 0; //0 - non include i gruppi nella selezione, 1 - include
NomeAttributo = "Anno"; //nel Configuratore, l'attributo deve avere la casella di controllo Selezione selezionata
valore = 1980;
Rif. Seleziona Elementi per dettagli(NomeAttributo, Valore, Modalità Gerarchia, Modalità Gruppo);
Mentre SprCont.GetElement()=1 Ciclo
.....<действия с очередным элементом>
FineCiclo;

Filtraggio in un ciclo

RefCotr = CreateObject("Directory.Employees");
SprSotr.UseParent(grpWorking);
DataUso Rif.(DataLavoro());
Rif. Seleziona elementi();
Mentre SprSotr. OttieniElemento()=1 ciclo

Se posizione amministrativa<>dlzhCarpenter Allora
....Continua; //saltiamo questo dipendente e andiamo all'inizio del ciclo
finisci se;

<действия с очередным элементом>

FineCiclo;

Ordinamento

Prima del campionamento, è possibile impostare l'ordinamento utilizzando i seguenti metodi:

CodiceOrdine()
NomeOrdine()
Ordine attributo(ReqName) //l'attributo deve avere la casella di controllo Ordinamento selezionata nel Configuratore
Ordine inverso()

Ad esempio, di seguito si apre una selezione di dipendenti, ordinati per numero in ordine decrescente:

RefCotr = CreateObject("Directory.Employees");
OrdineCodiciRif.();
Rif.Ordine inverso();
Rif.SelectItems();

Richiesta alla directory

La ricerca degli elementi della directory può essere organizzata tramite Richiesta. Ciò è spesso più conveniente se viene utilizzata una condizione di selezione complessa o un raggruppamento di elementi. Vedi maggiori dettagli. Richieste

Cerca un elemento

Cerca un elemento

RefCotr = CreateObject("Directory.Employees");
Se SprSotr. TrovaElemento(SelectSotr)=1 Allora
....//l'elemento diventa attuale
....SprSotr.Parent = grpWorking;
....RepCort.Write();
finisci se;

Cerca per codice

Se SprSotr. Trova per codice(1) = 1 Allora
....ElementOrGroup = Ref.CurrentElement();
finisci se;

Ricerca per nome

Se SprSotr. Trova per nome("Lavoro")=1 Allora
....grpWorking = Rif.CurrentItem();
finisci se;

modalità = 1; // 1 - ricerca all'interno della subordinazione stabilita (genitore) (impostazione predefinita); 0: cerca nell'intera directory
Flag di ricerca = 0; //1 - trova la corrispondenza esatta; 0: trova il nome in base ai primi caratteri (impostazione predefinita)
SprSotr.UseParent(grpWorking);
Se Ref.FindByName("Iv",Mode,SearchFlag)=1 Allora
....FirstWorkingIv = Rif.CurrentItem();
finisci se;

Cerca per dettagli

ReqName = "Anno"; //l'attributo deve avere la casella di controllo Ordinamento selezionata nel Configuratore
SearchGlobeFlag = 1; // 1 - cerca nell'intera directory, 0 - cerca all'interno della subordinazione
Se SprSotr. Trova per dettagli(ReqName,1980,SearchGlobeFlag)=1 Quindi
.....ElementoTrovato = Rif.ElementoCorrente();
finisci se;

Trovare un elemento in un ciclo

RefCotr = CreateObject("Directory.Employees");
SprSotr.UseParent(grpWorking);
DataUso Rif.(DataLavoro());
Rif. Seleziona elementi();
Mentre SprSotr. OttieniElemento()=1 ciclo

Se Admin.Position = dlzhCarpenter Allora
....Interrompi; //trovato un falegname che lavora! uscire dal giro
finisci se;

FineCiclo;
<действия с найденным элементом>

Richiesta alla directory

La ricerca di un elemento della directory può essere organizzata tramite Richiesta. Ciò è spesso più conveniente se viene applicata una condizione di selezione complessa. Vedi maggiori dettagli. Richieste

Rimozione di elementi

Rimozione diretta

RefCotr = CreateObject("Directory.Employees");
SprEmployee.FindElement(SelectEmployee);
Rif.Elimina(); //cancellazione immediata

Attenzione! Se elimini direttamente un elemento, assicurati che non ci siano riferimenti ad esso in altri oggetti. Ad esempio, il dipendente rimosso può essere utilizzato nel documento Ferie. Se viene eliminato, l'integrità referenziale del database verrà interrotta. In questo caso, si consiglia di utilizzare contrassegnato per la cancellazione.

È possibile ottenere a livello di codice un elenco di oggetti contenenti un collegamento all'oggetto da eliminare utilizzando il metodo FindLinks(object).

Contrassegnare per l'eliminazione

Per controllare l'integrità referenziale del database, gli elementi eliminati vengono semplicemente contrassegnati per l'eliminazione. Quindi, utilizzando uno speciale comando di menu Operazioni => "Eliminazione di oggetti contrassegnati" in modalità esclusiva, il sistema 1C controllerà l'integrità referenziale ed eliminerà fisicamente gli elementi dal database se non ci sono riferimenti ad essi in altri oggetti.

SprSotr = CreateObject("Directory.Dipendenti");
Ref.FindElement(SelectEmployee);
Rif.Elimina(0); //contrassegna per la cancellazione

//puoi controllare se un elemento è contrassegnato per l'eliminazione
//la funzione restituisce 1 - se contrassegnato, 0 - altrimenti
Marchio = Rif. FlagEliminazione();

//puoi deselezionare il segno di cancellazione
Ref.FindElement(SelectEmployee);
Rif. Deseleziona Elimina();

Transazioni

Quando elimini molti elementi della directory, puoi racchiudere un ciclo in una transazione per accelerare il lavoro. In questo caso l'effettiva cancellazione (contrassegno per la cancellazione) di tutti gli elementi avverrà solo con il comando CommitTransaction(). La directory è bloccata per la durata della transazione.

RefCotr = CreateObject("Directory.Employees");
Avvia transazione();

Rif.SelectItems();
Mentre SprCont.GetElement()=1 Ciclo
......Rif.Elimina(0); //contrassegna per la cancellazione
FineCiclo;

CommitTransaction();

Directory gerarchiche

L'elenco degli elementi della directory nel sistema 1C:Enterprise può essere multilivello. In questo caso, tutte le linee della directory saranno divise in 2 tipi: elementi di directory “semplici” e gruppi di directory. I gruppi consentono di spostarsi ai livelli inferiori di una directory a più livelli. Il numero possibile di livelli di annidamento delle directory viene impostato nel Configuratore.

L'uso di directory multilivello consente di organizzare l'immissione delle informazioni nella directory con il livello di dettaglio richiesto. Elementi e gruppi di elementi in una directory a più livelli possono essere trasferiti da un gruppo all'altro.

Attenzione! Gerarchico anche il libro di consultazione multilivello directory o directory con gruppi.
Un gruppo di directory in 1C viene spesso chiamato " genitore".

Creazione programmatica di un gruppo

RefCotr = CreateObject("Directory.Employees");

Rif. Un nuovo gruppo();
SprSotr.Name = "Funzionante";
Rif. Scrivi();

Rif.NuovoGruppo();
Nome Rif. = "Ignorato";
SprCotr.Write();

Attenzione! Nel Configuratore è possibile impostare l'attributo in modo che sia valido solo per un elemento, solo per un gruppo o per entrambi. Ad esempio, il campo Data di ricezione non ha senso per il Gruppo di lavoro. Pertanto, non dovresti accedere ai dettagli dell'elemento se lavori con un gruppo e viceversa.

Impostazione del gruppo corrente


Rif. UsaParent(grpLavoro); //ora siamo all'interno del gruppo di lavoro
Rif.SelectItems(); //apre una selezione di elementi del Gruppo di lavoro

RefCotr = CreateObject("Directory.Employees");
Rif. UsaParent(grpLavoro);
Rif.Nuovo(); //creazione di un nuovo elemento nel gruppo di lavoro

Se la directory è multilivello, sarà utile utilizzare i seguenti metodi e attributi che consentono di ottenere informazioni sull'elemento della directory corrente:

Metodo/attributo

Descrizione

Livello()

Questo metodo restituisce il livello dell'elemento corrente. Ad esempio, per un dipendente che fa parte del Gruppo di lavoro, otterremo il numero 2.

Esempio, output di una directory gerarchica sotto forma di albero:

RefCotr = CreateObject("Directory.Employees");
Rif.SelectItems();

//visualizza il rientro in base alla profondità di annidamento degli elementi
Per Nom=1 per Const.Level() Ciclo
.....Per segnalare(".....");
FineCiclo;

FineCiclo;

Questo gruppo() Questo metodo restituisce 1 se l'elemento della directory corrente è un gruppo o 0 se non è un gruppo.

Esempio, output dei dipendenti (i gruppi non vengono output):

RefCotr = CreateObject("Directory.Employees");
Rif.SelectItems();
Mentre Ref.GetItems()=1 Ciclo

Se Ref.ThisGroup()=1 Allora
......Continua; //salta i gruppi, vai all'inizio del ciclo
finisci se;
Report(Nome rif.);

FineCiclo;

Appartiene al Gruppo(...) Il metodo controlla se l'elemento della directory corrente appartiene al gruppo specificato (indipendentemente dal livello sottostante in cui si trova).
Restituisce: 1 - se l'elemento appartiene al gruppo specificato, 0 - in caso contrario.

Esempio visualizzazione di prodotti appartenenti al gruppo Alcolici, indipendentemente dal fatto che siano inclusi nei sottogruppi Champagne, Birra, Vodka, Vino, ecc.:




.....Notifica(SprProducts.Name);
finisci se;

FineCiclo;

attributo Genitore

Questo attributo contiene il genitore dell'elemento della directory corrente, ad es. il gruppo in cui si trova l'elemento corrente. Leggibile e scrivibile.

Esempio, trasferimento di tutti i prodotti dal gruppo Alcolici al gruppo Vendita:

DirectoryProdotti = CreaOggetto("Directory.Prodotti");
SprProducts.SelectItems();
Mentre SprProducts.GetItems()=1 Ciclo

Se Prodotti.Appartiene al gruppo(gruppoAlcohol)=1 Allora
.....SprSotr.Parent = grpSale;
.....RepCort.Write();
finisci se;

FineCiclo;

Oppure puoi renderlo più bello e spostare l'intero gruppo Alcol nel gruppo Vendita, quindi anche tutti i sottogruppi e gli elementi verranno trasferiti nel gruppo Vendita.

DirectoryProdotti = CreaOggetto("Directory.Prodotti");
SprProducts.FindItem(grpAlcohol);
SprProducts.Parent = grpSale;
SprProducts.Write();

Codice completo()

Restituisce una stringa contenente il codice completo dell'elemento della directory selezionata con tutti i livelli superiori separati dal carattere "/".

Ad esempio, "2/7/123"

Nome e cognome()

Restituisce una stringa contenente il nome completo dell'elemento della directory selezionato con tutti i livelli superiori separati dal carattere "/".

Ad esempio, "Alcool/Champagne/Sovietico"

Possibilità di selezionare un gruppo negli oggetti di dialogo

Spesso è conveniente per i dettagli sul modulo che hanno il tipo Directory disabilitare la possibilità di selezionare un gruppo. In questo campo è quindi possibile selezionare solo un elemento e non un gruppo. In generale, è più facile provare una volta che spiegare più volte.

Form.SelectEmployee. Selezione del gruppo(0); //disabilita la possibilità di selezionare un gruppo

Directory subordinate

Elenco- proprietario, questo è anche un libro di consultazione - maestro.
Vengono chiamate anche la directory del proprietario e la directory dello slave imparentato libri di riferimento.
In termini di database relazionale, la directory proprietaria è la tabella padre, la directory slave è la tabella figlia.

Assegnazione di directory subordinate

Qualsiasi directory può essere utilizzata da sola o essere subordinata a qualche altra directory. Ad esempio, un elenco di contratti può essere utilizzato separatamente oppure può essere collegato a un elenco di organizzazioni.

Per subordinare una directory a una qualsiasi delle directory già esistenti nel sistema, nel campo "Subordinato", selezionare il nome di questa directory. Tale directory nel sistema 1C:Enterprise è chiamata proprietario.

A differenza di una directory multilivello, in cui tutti gli elementi hanno la stessa struttura, l'utilizzo del meccanismo delle directory subordinate consente di collegare elementi di strutture diverse. In questo caso ogni elemento della directory subordinata sarà associato ad uno degli elementi della directory proprietaria.

Esternamente, lavorare con una directory subordinata nel sistema 1C:Enterprise apparirà così.

Se per una directory subordinata è impostata la modalità di visualizzazione sotto forma di elenco gerarchico, prima di utilizzare la directory è necessario selezionare l'elemento proprietario della directory. Quando visualizzata sullo schermo, la directory subordinata conterrà nel titolo il nome dell'elemento proprietario e l'elenco degli elementi della directory subordinata conterrà solo elementi correlati all'elemento proprietario. Quando l'elemento proprietario cambia, le informazioni nella finestra della directory subordinata verranno aggiornate di conseguenza.

Se si apre una directory subordinata senza selezionare l'elemento proprietario, nella finestra della directory subordinata non verrà visualizzato alcun elemento e nel titolo della finestra verrà visualizzato il messaggio "Elemento proprietario non specificato".

Quando si lavora con il sistema 1C:Enterprise, la visualizzazione sotto forma di elenco gerarchico può essere disabilitata per una directory subordinata. In questo caso tutti gli elementi di questa directory verranno visualizzati nella finestra della directory slave, ovvero gli elementi assegnati a proprietari diversi verranno visualizzati mescolati. Tuttavia, qualsiasi elemento di una directory subordinata “conosce” il suo proprietario: se per la directory è abilitata la modalità “Modifica in finestra di dialogo” (vedi sotto in “Creazione di moduli di directory”), il nome dell'elemento proprietario verrà visualizzato nel titolo della finestra di modifica degli elementi della directory.

Impostazione del proprietario attuale


SprAgreements.UseOwner(SelectContractor);
SprAgreements.SelectItems(); //apre una selezione di accordi della controparte selezionata
<...>

Informazioni sull'elemento corrente

Se la directory è subordinata, sarà utile utilizzare i seguenti metodi e attributi che consentono di ottenere informazioni sull'elemento della directory corrente:

Attributo

Descrizione

attributo Proprietario

Questo attributo contiene il proprietario dell'elemento corrente della directory subordinata, ad es. elemento della directory host a cui appartiene questo elemento. L'attributo è leggibile e scrivibile.

Esempio trasferimento di tutti i contratti da una controparte all'altra (la directory Contratti è subordinata alla directory Controparti):

DirectoryAgreements = CreateObject("Directory.Agreements");
SprAgreements.UseOwner(Counterparty1);
SprAgreements.SelectItems();
Mentre SprAgreements.GetElements()=1 Ciclo

SprAgreements.Owner = Controparte2;
SprAgreements.Write();

FineCiclo;


Dettagli periodici

Abilitando l'opzione "Periodico" è possibile specificare che un attributo di directory memorizzi la cronologia delle modifiche nel suo valore. Tale dettaglio nel sistema 1C:Enterprise è chiamato periodico e ha la seguente proprietà: a differenza dei dettagli “ordinari” (non periodici), il sistema 1C:Enterprise memorizza i valori di tale dettaglio in base alle date della loro modifica . Quando si accede al valore di tale attributo per una determinata data, il suo valore viene restituito per quella data o, se mancante, per la data precedente più vicina in cui è stato impostato il valore dell'attributo.

Questa proprietà dei dettagli dell'elenco consente, ad esempio, di organizzare facilmente l'archiviazione della cronologia dei tassi di cambio nell'elenco delle valute.

È possibile accedere ai dettagli periodici utilizzando il linguaggio integrato del sistema 1C:Enterprise: ricevi e registra il valore dei dettagli per una data specifica. Tuttavia, va tenuto presente che quando si riceve il valore di una variabile per una certa data, il suo valore viene recuperato per la data specificata o (se non c'è valore per la data specificata) per la data precedente più vicina, e il valore di la variabile periodica viene sempre registrata per la data specificata.

Nella modalità di utilizzo della configurazione per i dettagli periodici, è possibile aprire la finestra “Cronologia”. Questa finestra è una tabella composta da due colonne: la data in cui il valore dell'attributo della directory è stato modificato e il valore a partire da quella data. La finestra “Cronologia” consente di modificare direttamente la cronologia delle modifiche al valore dell'attributo: inserire nuove righe, modificare o eliminare quelle esistenti.

Metodi di dettaglio periodico
//in questo modo scopriamo quale categoria aveva il dipendente in una determinata data
Categoria = SprSort.Category.Get(SomeDate);

//questo è il modo in cui imposteremo la categoria del dipendente per una data specifica
Ref.Category.Set(SomeDate, NewCategory);

Attenzione! Questi metodi possono essere utilizzati se non è stato utilizzato in precedenza il metodo UseDate

Impostazione della data per il campionamento dei dettagli periodici

//è possibile impostare la data per il campionamento dei dettagli periodici per l'intera directory
Rif. UsaData(Qualche data);

//allora è già più basso è vietato utilizzare i metodi Set e Get
//l'accesso ai dettagli periodici diventa lo stesso dei dettagli regolari
Categoria = SprSotr.Categoria;
Stipendio iniziale = 6000;

Oggetto "Periodico"

Per lavorare con la cronologia dei dettagli periodici, è molto comodo utilizzare l'oggetto “Periodico”.

Ad esempio, visualizzare la cronologia della carriera del dipendente per l'anno corrente:

HistoryCareers = CreateObject("Periodico");
CareerHistory.UseObject("Posizione", SelectEmployee);
Cronologia carriera.SelectValues(Inizio anno(Data di lavoro(),Fine anno(Data di lavoro()));
Mentre HistoryCareers.GetValue()=1 Ciclo
....Report(String(CareerHistory.DateValue) + " " + String(CareerHistory.Value));
FineCiclo;

Puoi anche modificare ed eliminare valori utilizzando l'oggetto Periodico. Per un elenco completo dei metodi, vedere il Syntax Helper.

Esecuzione di documenti

Quando si pubblica un documento, è spesso necessario impostare un nuovo valore per un attributo periodico per una data specifica. Questo si chiama movimento dei documenti. In questo caso, dovresti utilizzare il metodo Imposta attributi directory:

Imposta i dettagli della directory(Dipendente, "Posizione", NuovaPosizione, DataSpostamento);

Fine della procedura

Se il documento ha una parte tabellare e si desidera collegare i movimenti del documento al numero di riga del documento, è necessario utilizzare il metodo BindRow.

Procedura ElaborazioneCondotta()

SelezionaRighe();
Mentre GetString()=1 Ciclo

BindString(NumeroRiga);
Imposta i dettagli della directory (dipendente, "Posizione", Nuova posizione, Data di spostamento);

FineCiclo;

Fine della procedura

Selezione dalla directory

La funzione di selezione consente di selezionare più valori da una ricerca o da un altro oggetto senza chiuderlo.Ad esempio, esiste un documento Fattura in cui l'utente può specificare diversi prodotti.

Organizzazione della selezione

Sintassi: OpenSelect(<Объект>,<ИмяФормы>,<КонтекстФормы>,<ФлагМножВыбора>,<ТекЗнач>)

OpenSelection("Directory.Nomenclature","FormForSelection",Cont,1);


...Nuova linea();
...Prodotto = Articolo;
Fine della procedura

Puoi utilizzare il contesto del modulo e andare immediatamente al gruppo desiderato, ad esempio:

OpenSelection("Directory.Nomenclature","FormForSelection",Cont,1);
Cont.UseParent(grpAlcohol);

Elaborazione proceduraFit(Elemento,FormContent)
...Nuova linea();
...Prodotto = Articolo;
Fine della procedura

Impostazione e acquisizione di valori dalla selezione

ContFormSelection. Imposta valore nella selezione(<ИмяРеквизита>,<Значение>)

<ИмяРеквизита>- riga con il nome dell'attributo del modulo di selezione del valore;
<Значение>- il valore dell'attributo.

ContFormSelection. Ottieni valore dalla selezione(<Выражение>)

<Выражение>- un'espressione stringa il cui valore viene calcolato nel contesto del modulo di selezione e restituito come risultato.

Altri metodi utili

Metodo

Descrizione

Visualizzazione() Imposta o legge il nome corrente del tipo di directory. Restituisce il nome corrente del tipo di directory, come specificato nel Configuratore, ad esempio "Dipendenti". L'impostazione del tipo di directory è possibile per i dettagli del tipo "Directory", ad es. directory di tipo indeterminato.
VisualizzaVisualizza() Ottieni una visualizzazione personalizzata della visualizzazione della directory come specificato nel configuratore.
Restituisce un valore stringa contenente una rappresentazione personalizzata della visualizzazione della directory (sinonimo).
SetAttribute(NomeAttributo, Valore) Imposta il valore dell'attributo in base al suo nome.
<ИмяРеквизита>- un'espressione stringa contenente il nome dell'attributo, come specificato nel configuratore.<Значение>- un'espressione contenente il valore dell'attributo da impostare.
OttieniAttributo(NomeAttributo) Ottieni il valore di un attributo tramite il suo nome. Restituisce il valore dell'attributo.
Selezionato()

Restituisce 1 - se l'elemento della directory è selezionato, 0 - se non selezionato. Spesso utilizzato per verificare la presenza di errori per garantire che vengano forniti tutti i dati richiesti.

Scegliere(...) Chiamare una finestra di dialogo per selezionare un elemento della directory.
Restituisce: 1 - se l'elemento è selezionato; 0 - se non selezionato. L'elemento selezionato diventa quello corrente.

Lettura della struttura delle directory

Ciclo secondo i libri di consultazione

Numero di DirectoryInConfiguration = Metadata.Directory();
Per Nom=1 al numero di directory nel ciclo di configurazione

cfgSpr = Metadati.Directory(Nom);
Identificatore = cfgSpr.Identificatore();
FullIdentifier = cfgSpr.FullIdentifier();
Sinonimo = cfgSpr.Sinonimo();

Le directory 1C sono un oggetto specializzato dell'albero dei metadati che serve a memorizzare informazioni di riferimento statiche. Ad esempio, nelle configurazioni tipiche è possibile visualizzare le seguenti visualizzazioni: , Nomenclatura, Dipendenti, Cespiti, ecc. Le informazioni nelle directory, di regola, non cambiano spesso. Le directory vengono successivamente utilizzate in quasi tutti gli oggetti contabili come sezione contabile o informazioni di riferimento.

Di seguito esamineremo l'impostazione e la progettazione di una directory dal configuratore utilizzando la directory "Nomenclatura" come esempio.

Scheda Base

La scheda "Base" specifica il nome, il sinonimo, la rappresentazione dell'oggetto e la descrizione dello scopo.

Scheda "Gerarchia directory".

Qui viene stabilita la gerarchia della directory.

La gerarchia in 1C 8.3 è di due tipi: “ gruppi ed elementi" E " elementi". La differenza è che nel primo caso solo una cartella (gruppo) può essere un genitore (cartella) e nel secondo caso anche un elemento può essere un genitore.

"Posiziona i gruppi in primo piano": la bandiera è responsabile della visualizzazione dei gruppi sotto forma di elenco.

Inoltre nelle impostazioni è possibile limitare il numero di gruppi nella gerarchia delle directory utilizzando l'impostazione appropriata.

Scheda Proprietari

Una directory può essere subordinata a un'altra directory. Ciò significa, dal punto di vista della configurazione di 1C 8.3, che l'attributo “Proprietario” diventa obbligatorio per l'elemento subordinato. Un esempio di tale connessione tra elenchi nelle configurazioni standard “Nomenclatura - Unità di misura”, “Controparti - Contratti di appaltatori”.

Il proprietario della directory può anche essere i seguenti oggetti di metadati: , .

Scheda Dati

Ottieni 267 lezioni video su 1C gratuitamente:

La scheda più importante dal punto di vista del programmatore. Contiene i dettagli della directory.

La directory contiene una serie di dettagli standard che non vengono modificati dal programmatore 1C 8.2; un elenco di essi può essere visualizzato facendo clic sul pulsante "Dettagli standard":

Mi soffermerò su ciascuno in modo più dettagliato:

  • Questo gruppo— un attributo di tipo booleano, che indica se si tratta di un gruppo o di un elemento. Disponibile solo nella directory gerarchica. Nota, il valore di questo attributo non può essere modificato in 1C: modalità Enterprise.
  • Codice— oggetti di scena, tipo numero o stringa (solitamente una stringa). Un numero assegnato automaticamente dal sistema. Tipicamente calcolato come (codice precedente + 1). Consiglio di utilizzare il tipo stringa, perché l'ordinamento dei valori numerici non funziona come previsto. Può essere utilizzato come presentazione di directory in un elenco e nei campi di input. Solitamente utilizzato per cercare un elemento quando si immette una stringa. Se è necessario rimuovere il campo Codice, inserire zero nella lunghezza della riga.
  • Nome— dettagli obbligatori, tipo di stringa. La lunghezza massima della riga è di 150 caratteri. Può essere utilizzato come presentazione di directory in un elenco e nei campi di input. Solitamente utilizzato per cercare un elemento quando si immette una stringa. Se è necessario rimuovere il campo Nome, immettere zero nella lunghezza della riga.
  • Genitore— un attributo del tipo DirectoryLink.<ИмяТекущегоСправочника>. Disponibile solo nella directory gerarchica. Indica il genitore superiore nella gerarchia. Se l'elemento o il gruppo si trova alla radice della directory, viene specificato il valore Directory.<ИмяТекущегоСправочника>.EmptyLink.
  • Proprietario— collegamento all'elemento proprietario dell'elemento della directory corrente (gruppo). Disponibile solo nella directory subordinata 1C.
  • FlagEliminazione— oggetti di scena di tipo Booleano. Responsabile della visualizzazione del “segno di cancellazione” nel sistema. Un elemento contrassegnato per l'eliminazione è considerato inutilizzabile, ma su di esso potrebbero rimanere vecchi movimenti di documenti.
  • Collegamento— campo di tipo stringa. Questo attributo memorizza un identificatore di oggetto univoco: GUID. Ciò che vediamo nel sistema in una visualizzazione chiamata “link” è solo una rappresentazione dell'oggetto. Non può essere modificato.
  • Predefinito— tipo booleano, mostra se l'elemento è predefinito, ne parleremo più avanti. Non può essere modificato.

La scheda “Dati” indica anche la rappresentazione della directory nel sistema; prima della versione 8.2.16 la rappresentazione poteva essere solo Codice o Nome. Nelle versioni recenti della piattaforma (a partire dalla 8.3), la vista può essere descritta in modo indipendente nel modulo di gestione utilizzando l'handler “ViewReceivingProcessing”.

Scheda Numerazione

Qui è possibile specificare le impostazioni della rubrica relative alla numerazione. Si consiglia di utilizzare la numerazione automatica. Il controllo di unicità è un flag che aiuta, se necessario, a rendere il codice univoco. Se con il flag impostato si tenta di scrivere un elemento di directory con codice non univoco, in 1C verrà visualizzato il messaggio “Il codice directory è diventato non univoco”.

Serie codici - determina come numerare la rubrica; è possibile inserire la numerazione della rubrica in base al proprietario. Ad esempio, la controparte "Horns and Hooves" avrà la propria numerazione dei contratti: "1, 2, 3", ecc.

Scheda Moduli

I moduli per la directory sono descritti qui. Se la configurazione viene avviata sia in modalità normale che gestita, per impostazione predefinita saranno presenti due schede con moduli: "principale" e "avanzata", diverse per le applicazioni normali e gestite.

Questa pagina ha una caratteristica importante della directory: "". Questa è una funzione molto comoda di 1C 8, che ti consente, durante la compilazione dei dati nel campo di immissione, di non entrare nella directory, ma di digitarne il nome, il codice, ecc. e seleziona l'elemento desiderato dall'elenco a discesa. Sembra questo:

Altra scheda

Nella scheda puoi accedere rapidamente ai moduli principali della directory: il modulo oggetto e il modulo gestore.

È inoltre possibile definire un elenco di elementi di directory predefiniti nella pagina. Si tratta di elementi che non possono essere eliminati in modalità Enterprise. Gli elementi predefiniti sono accessibili direttamente nel configuratore per nome, ad esempio: Directory.Nomenclatura.Servizio.

Questa scheda determina anche la modalità di blocco: automatica o controllata. Utilizzo della ricerca full-text, nonché informazioni di riferimento sulla directory, disponibili in 1C: modalità Enterprise.



Articoli casuali

Su