,
 (Half Day),(Poludnevni)
 against same operation,protiv istog radu
 by Role ,prema ulozi
 cannot be 0,ne može biti 0
 does not belong to the company: ,ne pripadaju tvrtki:
 has been freezed. \				Only Accounts Manager can do transaction against this account,je freezed. \ Samo računi vlasnici mogu učiniti transakciju protiv tog računa
" is less than equals to zero in the system, \						valuation rate is mandatory for this item","je manje nego jednaka nuli u sustavu, \ stopa za vrednovanje je obvezna za tu stavku"
 is mandatory,je obavezno
 is mandatory for GL Entry,je obvezna za upis GL
 is not a ledger,nije knjiga
 is not active,nije aktivan
 is now the default Fiscal Year. \			Please refresh your browser for the change to take effect.,Sada je zadana Fiskalna godina. \ Osvježite svoj preglednik za promjene stupiti na snagu.
 or the BOM is cancelled or inactive,ili BOM je otkazan ili neaktivne
 should be same as that in ,mora biti isti kao u
 will become ,će postati
"""Company History""",&quot;Povijest tvrtke&quot;
"""Team Members"" or ""Management""",&quot;Članovi tima&quot; ili &quot;upravljanje&quot;
# ###.##,# # # #. # #
"#,###",# # # #
"#,###.##",# # # #. # #
"#,###.###",# # # #. # # #
"#,##,###.##","#, # #, # # #. # #"
#.###,#. # # #
"#.###,##",#. # # # # #
%  Delivered,Isporučena%
% Amount Billed,% Iznos Naplaćeno
% Billed,Naplaćeno%
% Installed,Instalirani%
% Ordered,% Ž
% Received,% Pozicija
% of materials billed against this Delivery Note,% Materijala naplaćeno protiv ove otpremnici
% of materials billed against this Purchase Order.,% Materijala naplaćeno protiv ove narudžbenice.
% of materials billed against this Purchase Receipt,% Materijala naplaćeno protiv ove kupnje primitka
% of materials billed against this Sales Order,% Materijala naplaćeno protiv ovog prodajnog naloga
% of materials delivered against this Delivery Note,% Materijala dostavljenih protiv ove otpremnici
% of materials delivered against this Sales Order,% Materijala dostavljenih od ovog prodajnog naloga
% of materials ordered against this Purchase Requisition,% Materijala naredio protiv ove kupnje rekvizicije
% of materials received against this Purchase Order,% Materijala dobio protiv ove narudžbenice
"' can not be managed using Stock Reconciliation.\					You can add/delete Serial No directly, \					to modify stock of this item.","&#39;Ne može se upravljati pomoću Stock pomirenja. \ Možete dodati / izbrisati Serijski Ne izravno, \ mijenjati dionice ove stavke."
' does not exists in ,&#39;Ne postoji u
* Will be calculated in the transaction.,* Hoće li biti izračunata u transakciji.
"**Budget Distribution** helps you distribute your budget across months if you have seasonality in your business.To distribute a budget using this distribution, set this **Budget Distribution** in the **Cost Center**","Proračun ** Distribucija ** vam pomaže distribuirati svoj proračun preko mjeseca, ako imate sezonalnost u vašem business.To distribuirati proračun koristeći ovu distribuciju, postavite ovu ** Budget Distribution ** u ** troška **"
**Currency** Master,Valuta ** ** Master
**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,Fiskalna godina ** ** predstavlja financijsku godinu. Svi računovodstvene unose i druge glavne transakcije su praćeni od ** fiskalnu godinu **.
0,0
01,01
02,02
03,03
04,04
05,05
06,06
07,07
08,08
09,09
1,1
1 Currency = [?] FractionFor e.g. 1 USD = 100 Cent,1 valuta = [?] FractionFor npr. 1 USD = 100 centi
1. To maintain the customer wise item code and to make them searchable based on their code use this option,1. Za održavanje kupaca mudar Šifra i kako bi ih pretraživati ​​na temelju svog koda koristiti ovu opciju
10,10
100,100
11,11
12,12
12px,12px
13px,13px
14px,14px
15,15
15px,15px
16px,16px
2,2
2 days ago,Prije 2 dana
20,20
25,25
3,3
30,30
35,35
4,4
40,40
45,45
5,5
50,50
55,55
6,6
60,60
65,65
70,70
75,75
80,80
85,85
90,90
95,95
: It is linked to other active BOM(s),: To je povezano s drugom aktivnom BOM (e)
: Mandatory for a Recurring Invoice.,: Obvezni za Ponavljajući fakture.
<,&lt;
<=,&lt;=
"<a href=""#!Sales Browser/Customer Group"">To manage Customer Groups, click here</a>","<a href=""#!Sales Browser/Customer Group"">Za upravljati skupine kupaca, kliknite ovdje</a>"
"<a href=""#!Sales Browser/Item Group"">Manage Item Groups</a>","<a href=""#!Sales Browser/Item Group"">Upravljanje Stavka Grupe</a>"
"<a href=""#!Sales Browser/Territory"">To manage Territory, click here</a>","<a href=""#!Sales Browser/Territory"">Za upravljanje Territory, kliknite ovdje</a>"
"<a href=""#Sales Browser/Customer Group"">To manage Territory, click here</a>","<a href=""#Sales Browser/Customer Group"">Za upravljanje Territory, kliknite ovdje</a>"
"<a href=""#Sales Browser/Territory"">To manage Territory, click here</a>","<a href=""#Sales Browser/Territory"">Za upravljanje Territory, kliknite ovdje</a>"
"<a onclick=""msgprint('<ol>\<li><b>field:[fieldname]</b> - By Field\<li><b>naming_series:</b> - By Naming Series (field called naming_series must be present\<li><b>eval:[expression]</b> - Evaluate an expression in python (self is doc)\<li><b>Prompt</b> - Prompt user for a name\<li><b>[series]</b> - Series by prefix (separated by a dot); for example PRE.#####\</ol>')"">Naming Options</a>","<a onclick=""msgprint('<ol>\<li><b>field:[fieldname]</b> - By Field\<li><b>naming_series:</b> - By Naming Series (field called naming_series must be present\<li><b>eval:[expression]</b> - Evaluate an expression in python (self is doc)\<li><b>Prompt</b> - Prompt user for a name\<li><b>[series]</b> - Series by prefix (separated by a dot); for example PRE.#####\</ol>')"">Imenovanje Opcije</a>"
<b>Cancel</b> allows you change Submitted documents by cancelling them and amending them.,<b>Odustani</b> vam promijeniti Poslao dokumente tako da ih otkazivanjem i njihovih izmjena i dopuna.
"<span class=""sys_manager"">To setup, please go to Setup > Naming Series</span>","<span class=""sys_manager"">Za postavljanje, molimo idite na Postavke&gt; Naming serije</span>"
=,=
>,&gt;
>=,&gt; =
A,A
A Customer exists with same name,Kupac postoji s istim imenom
A Lead with this email id should exist,Olovo s ovom e-mail id trebala postojati
A Product is shown on the website and is linked to an item.,"Proizvod je prikazan na web stranici, a povezana je s točkom."
"A Product or a Service that is bought, sold or kept in stock.","Proizvod ili usluga koji je kupio, prodao ili čuva u skladištu."
A Supplier exists with same name,Dobavljač postoji s istim imenom
A logical Warehouse against which stock entries are made.,Logično Skladište protiv kojih dionica unosi su napravili.
A new popup will open that will ask you to select further conditions.,Novi popup će se otvoriti koji će od vas tražiti da odaberete dodatne uvjete.
A symbol for this currency. For e.g. $,Simbol za ovu valutu. Za npr. $
A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Treća strana distributer / prodavač / komisionar / suradnik / prodavač koji prodaje tvrtke proizvode za proviziju.
A user can have multiple values for a property.,Korisnik može imati više vrijednosti za imovinu.
A+,+
A-,-
AB+,AB +
AB-,AB-
AMC Expiry Date,AMC Datum isteka
ATT,ATT
Abbr,Abbr
About,Oko
About Us Settings,O nama Postavke
About Us Team Member,O nama reprezentativka
Above Value,Iznad Vrijednost
Absent,Odsutan
Acceptance Criteria,Kriterij prihvaćanja
Accepted,Primljen
Accepted Quantity,Prihvaćeno Količina
Accepted Warehouse,Prihvaćeno galerija
Account,Račun
Account Balance,Stanje računa
Account Details,Account Details
Account Head,Račun voditelj
Account Id,ID računa
Account Info,Informacije o računu
Account Name,Naziv računa
Account Type,Vrsta računa
Account: ,Račun:
"Accounting entry frozen up to this date, nobody can do / modify entry except authorized person","Računovodstvo ulazak zamrznuta do tog datuma, nitko ne može učiniti / mijenjati ulazak osim ovlaštene osobe"
Accounting journal entries.,Računovodstvo unosi u dnevnik.
Accounts,Računi
Accounts Browser,Računi preglednik
Accounts Frozen Upto,Računi Frozen Upto
Accounts Home,Računi Početna
Accounts Payable,Računi naplativo
Accounts Receivable,Potraživanja
Action,Akcija
Action Detail,Akcija Detalj
Action html,Akcija html
Active,Aktivan
Active: Will extract emails from ,Aktivnost: Hoće li izdvojiti e-pošte iz
Activity,Djelatnost
Activity Log,Aktivnost Prijava
Activity Name,Djelatnost Naziv
Activity Type,Aktivnost Tip
Actual,Stvaran
Actual Amount,Stvarni iznos
Actual Budget,Stvarni proračun
Actual Completion Date,Stvarni datum dovršenja
Actual Date,Stvarni datum
Actual End Date,Stvarni Datum završetka
Actual End Time,Stvarni Vrijeme završetka
Actual Qty,Stvarni Kol
Actual Qty (at source/target),Stvarni Kol (na izvoru / ciljne)
Actual Qty After Transaction,Stvarni Kol Nakon transakcije
Actual Quantity,Stvarni Količina
Actual Start Date,Stvarni datum početka
Actual Start Time,Stvarni Vrijeme početka
Add,Dodati
Add / Edit Taxes and Charges,Dodaj / Uredi poreza i pristojbi
Add A New Rule,Dodaj novo pravilo
Add A Property,Dodaj nekretninu
Add Attachments,Dodaj privitke
Add Bookmark,Dodaj Bookmark
Add CSS,Dodaj CSS
Add Column,Dodaj stupac
Add Message,Dodaj poruku
Add New Permission Rule,Dodati novo pravilo dozvolu
Add Reply,Dodaj Odgovor
Add Terms and Conditions for the Purchase Receipt. You can also prepare a Terms and Conditions Master and use the Template.,Dodaj Uvjete za kupnju primitka. Također možete pripremiti Uvjeti i odredbe Master i koristiti predložak.
Add Terms and Conditions for the Purchase Requisition. You can also prepare a Terms and Conditions Master and use the Template,Dodaj Uvjete za kupnju rekvizicija. Također možete pripremiti Uvjeti i odredbe Master i koristiti predložak
"Add Terms and Conditions for the Quotation like Payment Terms, Validity of Offer etc. You can also prepare a Terms and Conditions Master and use the Template","Dodaj Uvjete za kotaciju poput plaćanja, trajanje ponude, itd. Također možete pripremiti Uvjeti i odredbe Master i koristiti predložak"
Add code as &lt;script&gt;,Dodaj kod kao &lt;script&gt;
Add custom code to forms,Dodaj prilagođeni kod oblika
Add fields to forms,Dodaj polja na obrascima
Add headers for standard print formats,Dodaj zaglavlja za standardne formate ispisa
Add or Deduct,Dodavanje ili Oduzmite
Add rows to set annual budgets on Accounts.,Dodavanje redaka postaviti godišnje proračune na računima.
Add to To Do,Dodaj u Raditi
Add to To Do List of,Dodaj u napraviti popis od
Add/Remove Recipients,Dodaj / Ukloni primatelja
"Add/remove users, set roles, passwords etc","Dodavanje / uklanjanje korisnika, postaviti uloge, lozinke i sl."
Additional Columns,Dodatni stupci
Additional Conditions,Dodatni uvjeti
Additional Info,Dodatne informacije
Additional Tables,Dodatne Tablice
Address,Adresa
Address & Contacts,Adresa i kontakti
Address Desc,Adresa Desc
Address Details,Adresa Detalji
Address HTML,Adresa HTML
Address Line 1,Adresa Linija 1
Address Line 2,Adresa Linija 2
Address Line1,Adresa Line1
Address Line2,Adresa Redak2
Address Title,Adresa Naslov
Address Type,Adresa Tip
Address and other legal information you may want to put in the footer.,Adresa i druge pravne informacije koje svibanj želite staviti u podnožje.
Address to be displayed on the Contact Page,Adresa biti prikazana na Kontakt stranici
Adds a custom field to a DocType,Dodaje prilagođeni polja DOCTYPE
Adds a custom script (client or server) to a DocType,Dodaje prilagođeni scenarij (klijent ili poslužitelj) na DOCTYPE
Advance Amount,Predujam Iznos
Advance amount,Predujam iznos
Advanced Scripting,Napredna Scripting
Advanced Settings,Napredne postavke
Advances,Napredak
Advertisement,Reklama
After Sale Installations,Nakon prodaje postrojenja
"After cancelling the Purchase Requisition, a dialog box will ask you reason for cancellation which will be reflected in this field","Nakon poništenja Kupnja rekvizicije, dijaloški okvir će vas pitati razlog za otkaz koji će se odraziti i na tom polju"
Against,Protiv
Against Account,Protiv računa
Against Docname,Protiv Docname
Against Doctype,Protiv DOCTYPE
Against Document Date,Protiv dokumenta Datum
Against Document Detail No,Protiv dokumenta Detalj No
Against Document No,Protiv dokumentu nema
Against Expense Account,Protiv Rashodi račun
Against Income Account,Protiv računu dohotka
Against Journal Voucher,Protiv Journal Voucheru
Against Purchase Invoice,Protiv Kupnja fakture
Against Sales Invoice,Protiv prodaje fakture
Against Voucher,Protiv Voucheru
Against Voucher Type,Protiv voucher vrsti
Agent,Agent
"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Sales BOM Item.Note: BOM = Bill of Materials","Agregat skupina ** stavki ** u drugoj točki ** **. To je korisno ako ste vezanje određene artikle ** ** u paketu i održavanje zalihe pakiran ** stavki ** a ne agregata ** artikla **. Paket ** artikla ** će &quot;Je kataloški Stavka&quot; kao &quot;Ne&quot; i &quot;Je li prodaja artikla&quot; kao &quot;Da&quot;, na primjer:. Ako prodajete Prijenosna računala i Ruksaci odvojeno i imaju posebnu cijenu ako kupac kupuje oboje , onda laptop + ruksak će biti novi Prodaja BOM Item.Note: BOM = Bill materijala"
Aging Date,Starenje Datum
All Addresses.,Sve adrese.
All Contact,Sve Kontakt
All Contacts.,Svi kontakti.
All Customer Contact,Sve Kupac Kontakt
All Day,All Day
All Employee (Active),Sve zaposlenika (aktivna)
All Lead (Open),Sve Olovo (Otvoreno)
All Products or Services.,Svi proizvodi i usluge.
All Sales Partner Contact,Sve Kontakt Prodaja partner
All Sales Person,Sve Prodaje Osoba
All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Sve transakcije prodaje mogu biti označene protiv više osoba ** prodajnim **, tako da možete postaviti i pratiti ciljeve."
All Supplier Contact,Sve Dobavljač Kontakt
All attendance dates inbetween selected Attendance From Date and Attendance To Date will come in the template with employees list.,Sve stadionu datira između ta dva odabrana Gledatelji od datuma i posjećenost do danas će doći u predlošku sa zaposlenicima popisu.
"All export related fields like currency, conversion rate, export total, export grand total etc are available in <br>Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Svi izvoz srodnih područja kao što su valute, stopa pretvorbe, izvoz, izvoz ukupno Sveukupno itd su dostupni u <br> Otpremnica, POS, citat, prodaja Račun, prodajnog naloga i sl."
"All import related fields like currency, conversion rate, import total, import grand total etc are available in <br>Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Sve uvozne srodnih područja kao što su valute, stopa pretvorbe, uvoz, uvoz ukupno Sveukupno itd su dostupni u <br> Kupnja Primitak, Dobavljač citat, Otkup fakture, Narudžbenica itd."
All items have already been transferred \				for this Production Order.,Svi predmeti su već prenesena \ ovoj proizvodnji Reda.
"All possible Workflow States and roles of the workflow. <br>Docstatus Options: 0 is""Saved"", 1 is ""Submitted"" and 2 is ""Cancelled""","Sve moguće Workflow Države i uloge tijeka rada. <br> Docstatus Opcije: 0 je &quot;Spremljeno&quot;, jedan je &quot;Zaprimljeno&quot; i 2. &quot;Otkazano&quot;"
Allocate,Dodijeliti
Allocate leaves for the year.,Dodjela lišće za godinu dana.
Allocated (%),Dodijeljeni (%)
Allocated Amount,Dodijeljeni iznos
Allocated Budget,Dodijeljeni proračuna
Allocated amount,Dodijeljeni iznos
Allow Attach,Dopustite Priloži
Allow Bill of Materials,Dopustite Bill materijala
Allow Negative Balance,Dopustite negativan saldo
Allow Negative Stock,Dopustite negativnu Stock
Allow Production Order,Dopustite proizvodnom nalogu
Allow Rename,Dopustite Preimenuj
Allow Samples,Dopustite Uzorci
Allow User,Dopusti korisnika
Allow Users,Omogućiti korisnicima
Allow on Submit,Dopusti na Submit
Allow the following users to make Leave Applications for block days.,Dopusti sljedeći korisnicima da ostavite Prijave za blok dana.
Allow this price in purchase related forms,Dopusti ovu cijenu za kupnju srodnih oblika
Allow this price in sales related forms,Dopusti ovu cijenu u prodaji srodnih oblika
Allow user to login only after this hour (0-24),Dopustite korisniku da prijavite tek nakon tog vremena (0-24)
Allow user to login only before this hour (0-24),Dopustite korisniku se prijaviti samo prije tog vremena (0-24)
Allowance Percent,Dodatak posto
Allowed,Dozvoljen
Amend,Ispraviti
Amended From,Izmijenjena Od
Amendment Date,Amandman Datum
Amount,Iznos
Amount <=,Iznos &lt;=
Amount >=,Iznos&gt; =
Amount*,Iznos *
"An icon file with .ico extension. Should be 16 x 16 px. Generated using a favicon generator. [<a href=""http://favicon-generator.org/"" target=""_blank"">favicon-generator.org</a>]","Ikona datoteke s nastavkom. Ico. Treba biti 16 x 16 px. Generirano pomoću favicon generator. [ <a href=""http://favicon-generator.org/"" target=""_blank"">favicon-generator.org</a> ]"
Analytics,Analitika
Answer,Odgovoriti
"Any other comments, noteworthy effort that should go in the records.","Svi ostali komentari, značajan napor da bi trebao ići u evidenciji."
Applicable Holiday List,Primjenjivo odmor Popis
Applicable To (Designation),Odnosi se na (Oznaka)
Applicable To (Employee),Odnosi se na (Radnik)
Applicable To (Role),Odnosi se na (uloga)
Applicable To (User),Odnosi se na (Upute)
Applicable only if valuation method is moving average,Primjenjivo samo ako metoda vrednovanja se kreće prosjek
Applicant Name,Podnositelj zahtjeva Ime
Applicant for a Job,Podnositelj zahtjeva za posao
Applicant for a Job (extracted from jobs email).,Podnositelj zahtjeva za posao (izvađen iz radnih e).
Applications for leave.,Prijave za odmor.
Applies to Company,Odnosi se na Društvo
Apply / Approve Leaves,Nanesite / Odobri lišće
Appraisal,Procjena
Appraisal Goal,Procjena gol
Appraisal Goals,Ocjenjivanje Golovi
Appraisal Template,Procjena Predložak
Appraisal Template Goal,Procjena Predložak cilja
Appraisal Template Title,Procjena Predložak Naslov
Approval Status,Status odobrenja
Approved,Odobren
Approver,Odobritelj
Approving Role,Odobravanje ulogu
Approving User,Odobravanje korisnika
Are you sure you want to delete the attachment?,Jeste li sigurni da želite izbrisati privitak?
Arial,Arial
Arrear Amount,Iznos unatrag
"As a best practice, do not assign the same set of permission rule to different Roles instead set multiple Roles to the User","Kao najbolje prakse, ne dodijeliti isti skup dozvola pravilu se različitim ulogama umjesto postaviti više uloge Korisniku"
As existing qty for item: ,Kao postojeće Qty za stavke:
As per Stock UOM,Kao po burzi UOM
Ascending,Uzlazni
Assign To,Dodijeliti
Assigned By,Dodijeljen od strane
Associate a DocType to the Print Format,Povežite DOCTYPE za ispis formatu
Atleast one warehouse is mandatory,Atleast jednom skladištu je obavezno
Attach,Pričvrstiti
Attach Document Print,Priloži dokument Ispis
Attachments,Privitci
Attempted to Contact,Pokušaj Kontakt
Attendance,Pohađanje
Attendance Control Panel,Gledatelja Upravljačka ploča
Attendance Date,Gledatelja Datum
Attendance Details,Gledatelja Detalji
Attendance From Date,Gledatelja Od datuma
Attendance To Date,Gledatelja do danas
Attendance record.,Gledatelja rekord.
Attributions,Pripisivanje
Authorization Control,Odobrenje kontrole
Authorization Rule,Autorizacija Pravilo
Authorized Role (Frozen Entry),Ovlašteni Uloga (Blokiran ulaz)
Authourized Role (Frozen Entry),Authourized Uloga (Blokiran ulaz)
Auto Email Id,Auto E-mail ID
Auto Name,Auto Ime
Auto generated,Automatski generirano
Automatically updated via Stock Entry of type Manufacture/Repack,Automatski ažurira putem burze Unos tipa Proizvodnja / prepakirati
Autoreply when a new mail is received,Automatski kad nova pošta je dobila
Available Qty at Warehouse,Dostupno Kol na galeriju
"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Dostupan u BOM, otpremnici, Otkup fakture, Proizvodnja Red, Narudžbenica, Otkup Potvrda, prodaja Račun, prodajnog naloga, Stock Stupanje, timesheet"
Average Discount,Prosječna Popust
B,B
B+,B +
B-,B-
BILL,Bill
BILLJ,BILLJ
BOM,BOM
BOM Detail No,BOM Detalj Ne
BOM Explosion Item,BOM eksplozije artikla
BOM Item,BOM artikla
BOM No,BOM Ne
BOM No. for a Finished Good Item,BOM broj za Gotovi Dobar točki
BOM Operation,BOM Operacija
BOM Operations,BOM operacije
BOM Replace Tool,BOM Zamijenite alat
BOM replaced,BOM zamijeniti
Background Color,Boja pozadine
Background Image,Pozadina slike
Background shade of the top menu bar,Pozadina nijansu gornjem izborniku
Bank,Banka
Bank A/C No.,Banka / C br
Bank Account,Žiro račun
Bank Account No.,Žiro račun broj
Bank Balance,Banka bilanca
Bank Name,Ime banke
Bank Reconciliation,Banka pomirenje
Bank Reconciliation Detail,Banka Pomirenje Detalj
Bank Voucher,Banka bon
Bank or Cash,Banka ili gotovina
Banner,Zastava
Banner HTML,Banner HTML
Barcode,Barkod
Based On,Na temelju
Based on,Na temelju
Basic Info,Osnovne informacije
Basic Information,Osnovne informacije
Basic Rate,Osnovna stopa
Basic Rate*,Osnovna stopa *
Batch,Serija
Batch (lot) of an Item.,Hrpa (puno) od točke.
Batch Finished Date,Hrpa Završio Datum
Batch ID,Hrpa ID
Batch No,Hrpa Ne
Batch Started Date,Hrpa Autor Date
Begin this page with a slideshow of images,Počnite ovu stranicu s slideshow slika
Better Prospects,Bolji izgledi
Bill Date,Bill Datum
Bill No,Bill Ne
Bill of Material to be considered for manufacturing,Bill of material treba uzeti u obzir za proizvodnju
Bill of Materials,Bill materijala
Bill of Materials (BOM),Bill materijala (BOM)
Billed,Naplaćeno
Billed Amt,Naplaćeno Amt
Billed Quantity,Naplaćeno Količina
Billing Status,Naplata Status
Bills raised by Suppliers.,Mjenice podigao dobavljače.
Bills raised to Customers.,Mjenice podignuta na kupce.
Bin,Kanta
Bio,Bio
Birth Date,Datum rođenja
Black,Crn
Blob,Grudvica
Block Date,Blok Datum
Block Days,Blok Dani
Block Holidays on important days.,Blok Odmor o važnim dana.
Block leave applications by department.,Blok ostaviti aplikacija odjelu.
Blog,Blog
Blog Subscriber,Blog Pretplatnik
Blog entry.,Blog ulazak.
Blood Group,Krv Grupa
Bookmarks,Favoriti
Branch,Grana
Brand,Marka
Brand HTML,Marka HTML
Brand Name,Brand Name
"Brand is what appears on the top-right of the toolbar. If it is an image, make sure ithas a transparent background and use the &lt;img /&gt; tag. Keep size as 200px x 30px","Brand je ono što se pojavljuje na gornjem desnom kutu alatne trake. Ako je to slika, pobrinite ithas transparentan pozadini i koristiti &lt;img /&gt; oznaku. Držite veličinu 200px x 30px"
Brand master.,Marka majstor.
Branding and Printing,Branding i ispis
Brands,Marke
Breakdown,Slom
Budget,Budžet
Budget Allocated,Proračun Dodijeljeni
Budget Control,Proračun kontrola
Budget Detail,Proračun Detalj
Budget Details,Proračunski Detalji
Budget Distribution,Proračun Distribucija
Budget Distribution Detail,Proračun Distribucija Detalj
Budget Distribution Details,Proračun raspodjele Detalji
Bulk Email,Bulk Email
Bulk Email records.,Bulk Email Records.
Bundle items at time of sale.,Bala stavke na vrijeme prodaje.
Button,Dugme
Buyer of Goods and Services.,Kupac robe i usluga.
Buying,Kupovina
Buying Cost,Kupnja troškova
Buying Cost will be updated from Purchase Orders and Purchase Receipts. <br>The buying cost will calculated by moving average method.,Kupnja Troškovi će biti ažurirana narudžbenice i kupiti primicima. <br> Trgovačke trošak će izračunati prosječnu kreće metodu.
Buying Home,Kupnja Početna
By,Po
C,C
C-FORM/,C-FORM /
C-Form,C-Form
C-Form Applicable,C-obrascu
C-Form Invoice Detail,C-Obrazac Račun Detalj
C-Form No,C-Obrazac br
CGHelp,CGHelp
CI/2010-2011/,CI/2010-2011 /
COMM-,COMM-
CSS,CSS
CTC,CTC
CUST,Cust
CUSTMUM,CUSTMUM
Calculate Charges,Izračun troškova
Calculate Tax,Izračun poreza
Calculate Taxes and Charges,Izračun poreza i pristojbi
Calculate Total Score,Izračunajte ukupni rezultat
Calendar,Kalendar
Calendar Events,Kalendar događanja
Call,Nazvati
Campaign,Kampanja
Campaign Name,Naziv kampanje
Can only be exported by users with role 'Report Manager',Može biti samo izvoze od strane korisnika s ulogom &#39;Report Manager&#39;
Cancel,Otkazati
Cancel Reason,Odustani razlog
Cancel permission also allows the user to delete a document (if it is not linked to any other document).,Odustani dozvola također omogućuje korisniku da izbrisati dokument (ako nije povezan s bilo kojim drugim dokumentom).
Cancelled,Otkazan
Cannot ,Nemoguće
Capacity,Kapacitet
Capacity Units,Kapacitet jedinice
Career History,Karijera Povijest
Carry Forward,Prenijeti
Carry Forwarded Leaves,Nosi proslijeđen lišće
Cash,Gotovina
Cash Voucher,Novac bon
Cash/Bank Account,Novac / bankovni račun
Category,Kategorija
Category of customer as entered in Customer master,Kategorija klijenta ušao u Customer gospodara
Cell Number,Mobitel Broj
Center,Centar
"Certain documents should not be changed once final, like an Invoice for example. The final state for such documents is called <b>Submitted</b>. You can restrict which roles can Submit.","Određene dokumente ne treba mijenjati jednom finalu, kao i račun za primjer. Konačno stanje za takvim dokumentima se zove <b>Postavio.</b> Možete ograničiti koje uloge mogu Submit."
Certificate,Certifikat
Challan Date,Challan Datum
Challan No,Challan Ne
Change UOM for an Item.,Promjena UOM za predmet.
Change background fonts etc,Promjena pozadine fontovi itd
"Change entry properties (hide fields, make mandatory etc)","Promjena ulazne svojstva (skrivanje polja, čine obaveznu itd.)"
Change the starting / current sequence number of an existing series.,Promjena polaznu / tekući redni broj postojeće serije.
Channel Partner,Channel Partner
Charge,Naboj
Chargeable,Naplativ
Chart of Accounts,Kontnog
Chart of Cost Centers,Grafikon troškovnih centara
Chat,Razgovor
Cheating FieldPlease do not delete ,Varanje FieldPlease ne brisati
Check,Provjeriti
Check / Uncheck roles assigned to the Profile. Click on the Role to find out what permissions that Role has.,Provjerite / Odznačite uloge dodijeljene profil. Kliknite na ulozi saznati što dozvole da uloga.
Check all the items below that you want to send in this digest.,Provjerite sve stavke u nastavku koje želite poslati u ovom svariti.
Check how the newsletter looks in an email by sending it to your email.,Pogledajte kako izgleda newsletter u e-mail tako da ga šalju na e-mail.
"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Provjerite je li ponavljajući fakture, poništite zaustaviti ponavljajući ili staviti odgovarajući datum završetka"
"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Provjerite ako trebate automatske ponavljajuće fakture. Nakon odavanja prodaje fakturu, ponavljajućih sekcija će biti vidljiv."
Check if you want to send salary slip in mail to each employee while submitting salary slip,"Provjerite ako želite poslati plaće slip u pošti svakom zaposleniku, dok podnošenje plaće slip"
Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Označite ovo ako želite prisiliti korisniku odabir seriju prije spremanja. Tu će biti zadana ako to provjerili.
Check this if you want to show in website,Označite ovo ako želite pokazati u web
Check this to make this the default letter head in all prints,Provjerite to napraviti ovu glavu zadani slovo u svim otisaka
Check this to pull emails from your mailbox,Provjerite to povući e-pošte iz poštanskog sandučića
Check to activate,Provjerite za aktiviranje
Check to make Shipping Address,Provjerite otprema adresu
Check to make primary address,Provjerite primarnu adresu
Checked,Provjeren
"Checking Operator (To Fld, Operator, From Fld)","Provjera operatora (Za FLD, operator, od FLD)"
Cheque,Ček
Cheque Date,Ček Datum
Cheque Number,Ček Broj
Child Tables are shown as a Grid in other DocTypes.,Dijete Tablice su prikazane kao Grid u drugim DocTypes.
City,Grad
City/Town,Grad / Mjesto
Claim Amount,Iznos štete
Claims for expenses made on behalf of the organization.,Potraživanja za troškove učinjene u ime organizacije.
Class / Percentage,Klasa / Postotak
Classification of Customers by region,Klasifikacija kupaca po regiji
Clear Cache & Refresh,Clear Cache &amp; Osvježi
Clear Pending,Vedro čekanju
Clear Table,Jasno Tablica
Clearance Date,Razmak Datum
Click on button in the 'Condition' column and select the option 'User is the creator of the document',Kliknite na gumb u &#39;hotela&#39; stupcu i odaberite opciju &#39;Korisnik je kreator dokument&#39;
Click on edit button to start a new report.,Kliknite na uredi gumb to početak novog izvješća.
Click to Expand / Collapse,Kliknite na Proširi / Sažmi
Client,Klijent
Client Script,Klijent Skripta
Closed,Zatvoreno
Closing Account Head,Zatvaranje računa šefa
Closing Date,Datum zatvaranja
Closing Fiscal Year,Zatvaranje Fiskalna godina
CoA Help,CoA Pomoć
Code,Šifra
Cold Calling,Hladno pozivanje
Collections,Zbirke
Color,Boja
Column Break,Kolona Break
Columns,Kolumne
Comma separated list of email addresses,Zarez odvojen popis e-mail adrese
Comment,Komentirati
Comment By,Komentar
Comment By Fullname,Komentar FULLNAME
Comment Date,Komentar Datum
Comment Docname,Komentar Docname
Comment Doctype,Komentar DOCTYPE
Comment Time,Komentar Vrijeme
Comments,Komentari
Commission Rate,Komisija Stopa
Commission Rate (%),Komisija stopa (%)
Commission partners and targets,Komisija partneri i ciljevi
Communication,Komunikacija
Communication HTML,Komunikacija HTML
Communication History,Komunikacija Povijest
Communication Log,Komunikacija Prijava
Communication Medium,Komunikacija srednje
Communication by,Komunikacija
Communication log.,Komunikacija dnevnik.
Communication type,Komunikacija putovanja
Company,Društvo
Company Control,Tvrtka Kontrola
Company Details,Tvrtka Detalji
Company History,Povijest tvrtke
Company History Heading,Povijest tvrtke Naslov
Company Info,Podaci o tvrtki
Company Introduction,Tvrtka Uvod
Company Name,Ime tvrtke
Company branches.,Tvrtka grane.
Company departments.,Tvrtka odjeli.
Company registration numbers for your reference. Example: VAT Registration Numbers etc.,Tvrtka registracijski brojevi za svoju referencu. Primjer: PDV registracijski brojevi i sl.
Company registration numbers for your reference. Tax numbers etc.,Tvrtka registracijski brojevi za svoju referencu. Porezni brojevi itd.
Complaint,Prigovor
Complete By,Kompletan Do
Completed,Dovršen
Completion Date,Završetak Datum
Completion Status,Završetak Status
Confirmed orders from Customers.,Potvrđeno narudžbe od kupaca.
Consider Tax or Charge for,Razmislite poreza ili pristojbi za
"Consider this Price List for fetching rate. (only which have ""For Buying"" as checked)",Razmislite ovom cjeniku za dobavljanje stopu. (Samo što su &quot;Za kupnju&quot; kao provjereni)
Consultant,Konzultant
Consumed Qty,Potrošeno Kol
Contact,Kontaktirati
Contact Control,Kontaktirajte kontrolu
Contact Desc,Kontakt ukratko
Contact Details,Kontakt podaci
Contact Email,Kontakt e
Contact HTML,Kontakt HTML
Contact Info,Kontakt Informacije
Contact Mobile No,Kontaktirajte Mobile Nema
Contact Name,Kontakt Naziv
Contact No,Kontaktirajte Ne
Contact No.,Kontakt broj
Contact Person,Kontakt osoba
Contact Type,Vrsta kontakta
Contact Us Settings,Kontaktirajte nas Settings
Contact in Future,Kontakt u budućnosti
"Contact options, like ""Sales Query, Support Query"" etc each on a new line or separated by commas.","Kontakt opcije, poput &quot;Sales Query, Podrška upit&quot; itd jedni na novoj liniji ili odvojene zarezima."
Contacted,Kontaktirao
Content,Sadržaj
Content Type,Vrsta sadržaja
Content in markdown format that appears on the main side of your page,Sadržaj u smanjenje formatu koji se pojavljuje na glavnoj strani stranice
Content web page.,Sadržaj web stranica.
Contra Voucher,Contra bon
Contract End Date,Ugovor Datum završetka
Control Panel,Upravljačka ploča
Conversion Factor,Konverzijski faktor
Conversion Rate,Stopa konverzije
Convert into Recurring Invoice,Pretvori u Ponavljajući fakture
Converted,Pretvoreno
Copyright,Autorsko pravo
Core,Srž
Cost Center,Troška
Cost Center Details,Troška Detalji
Cost Center Name,Troška Name
Cost Center must be specified for PL Account: ,Troška mora biti naveden za PL računa:
Cost to Company,Troškovi Društva
Costing,Koštanje
Country,Zemlja
Country Name,Država Ime
Create,Stvoriti
Create Bank Voucher for the total salary paid for the above selected criteria,Stvaranje Bank bon za ukupne plaće isplaćene za gore odabranih kriterija
Create Production Orders,Stvaranje radne naloge
Create Receiver List,Stvaranje Receiver popis
Create Salary Slip,Stvaranje plaće Slip
"Create a price list from Price List master and enter standard ref rates against each of them. On selection of a price list in Quotation, Sales Order or Delivery Note, corresponding ref rate will be fetched for this item.","Stvaranje cjenik iz Cjenika gospodara i unijeti standardne Ref. stope jedni protiv njih. Na izboru cjeniku u ponudu, prodajnog naloga ili otpremnici, odgovara ref stopa će biti preuzeta za tu stavku."
Create and Send Newsletters,Stvaranje i slati newslettere
Created Account Head: ,Objavljeno račun voditelj:
Created Customer Issue,Objavljeno Kupac Issue
Created Group ,Objavljeno Grupa
Created Opportunity,Objavljeno Opportunity
Created Support Ticket,Objavljeno Podrška karata
Creates salary slip for above mentioned criteria.,Stvara plaće slip za gore navedene kriterije.
Credit,Kredit
Credit Amt,Kreditne Amt
Credit Card Voucher,Kreditne kartice bon
Credit Controller,Kreditne kontroler
Credit Days,Kreditne Dani
Credit Limit,Kreditni limit
Credit Note,Kreditne Napomena
Credit To,Kreditne Da
Criteria Name,Kriteriji Ime
Cross List Item Group,Križ Group stavku popisa
Cross Listing of Item in multiple groups,Križ Oglas stavke u više grupa
Currency,Valuta
Currency & Price List,Valuta &amp; Cjenik
Currency Format,Valuta Format
Currency Name,Valuta Ime
Current Accommodation Type,Trenutni Tip smještaja
Current Address,Trenutna adresa
Current BOM,Trenutni BOM
Current Fiscal Year,Tekuće fiskalne godine
Current Stock,Trenutni Stock
Current Stock UOM,Trenutni kataloški UOM
Current Value,Trenutna vrijednost
Current status,Trenutni status
Cust/Supp Address,Cust / Supp Adresa
Cust/Supp Name,Cust / Supp Ime
Custom,Običaj
Custom Autoreply Message,Prilagođena Automatski Poruka
Custom CSS,Prilagođena CSS
Custom Field,Prilagođena polja
Custom Message,Prilagođena poruka
Custom Query,Prilagođena upita
Custom Reports,Prilagođena izvješća
Custom Script,Prilagođena skripta
Custom Startup Code,Prilagođena Pokretanje Šifra
Custom?,Prilagođena?
Customer,Kupac
Customer / Item Name,Kupac / Stavka Ime
Customer Account,Kupac račun
Customer Address,Kupac Adresa
Customer Addresses And Contacts,Kupac adrese i kontakti
Customer Code,Kupac Šifra
Customer Codes,Kupac Kodovi
Customer Details,Korisnički podaci
Customer Feedback,Kupac Ocjena
Customer Group,Kupac Grupa
Customer Group Name,Kupac Grupa Ime
Customer Intro,Kupac Uvod
Customer Issue,Kupac Issue
Customer Issue No,Kupac Izdavanje Ne
Customer Issue against a Serial No (warranty).,Kupac izdanje protiv Tekući broj (jamstvo).
Customer Master created by ,Kupac Master stvorio
Customer Name,Naziv klijenta
Customer Type,Vrsta klijenta
Customer classification tree.,Kupac klasifikacija stablo.
Customer database.,Kupac baze.
Customer's Currency,Kupca valuta
Customer's Item Code,Kupca Stavka Šifra
Customer's Vendor,Kupca Prodavatelj
Customer's currency,Kupca valuta
"Customer's currency - If you want to select a currency that is not the default currency, then you must also specify the Currency Conversion Rate.","Kupca valuta - Ako želite odabrati valutu koja nije zadana valuta, onda morate odrediti stopu pretvorbe valuta."
Customer/Supplier,Kupac / Dobavljač
Customerwise Discount,Customerwise Popust
Customize,Prilagodite
Customize Form,Prilagodite obrazac
Customize Form Field,Prilagodba polja obrasca
"Customize Label, Print Hide, Default etc.","Prilagodite oznaku, print sakriti, Zadani itd."
Customize the Notification,Prilagodite Obavijest
Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Prilagodite uvodni tekst koji ide kao dio tog e-maila. Svaka transakcija ima zaseban uvodni tekst.
DN,DN
DN Detail,DN Detalj
Daily,Svakodnevno
"Daily, weekly, monthly email Digests","Dnevno, tjedno, mjesečno e Razgradni"
Danger,Opasnost
Data,Podaci
Data Import,Uvoz podataka
Data Import Tool,Uvoz podataka alat
Database,Baza podataka
Database of potential customers.,Baza potencijalnih kupaca.
Date,Datum
Date Format,Datum Format
Date Of Retirement,Datum odlaska u mirovinu
Date is repeated,Datum se ponavlja
Date of Birth,Datum rođenja
Date of Issue,Datum izdavanja
Date of Joining,Datum Ulazak
Date on which lorry started from supplier warehouse,Datum na koji je kamion počeo od dobavljača skladištu
Date on which lorry started from your warehouse,Datum na koji je kamion počeo iz skladišta
Date on which the lead was last contacted,Datum na koji je vodstvo zadnje kontaktirao
Dates,Termini
Datetime,Datetime
Days for which Holidays are blocked for this department.,Dani za koje Praznici su blokirane za ovaj odjel.
Dealer,Trgovac
Dear,Drag
Debit,Zaduženje
Debit Amt,Rashodi Amt
Debit Note,Rashodi Napomena
Debit To,Rashodi za
Debit or Credit,Itnim
Deduct,Odbiti
Deduction,Odbitak
Deduction Type,Odbitak Tip
Deduction1,Deduction1
Deductions,Odbici
Default,Zadani
Default Account,Zadani račun
Default BOM,Zadani BOM
Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Zadani banka / Novčani račun će se automatski ažuriraju u POS računu, kada je ovaj mod odabran."
Default Bank Account,Zadani bankovni račun
Default Commission Rate,Zadani komisija Ocijenite
Default Company,Zadani Tvrtka
Default Cost Center,Zadani troška
Default Cost Center for tracking expense for this item.,Zadani troška za praćenje trošak za tu stavku.
Default Currency,Zadani valuta
Default Customer Group,Zadani Korisnik Grupa
Default Expense Account,Zadani Rashodi račun
Default Home Page,Zadani Početna stranica
Default Home Pages,Zadani Početna stranica
Default Income Account,Zadani Prihodi račun
Default Item Group,Zadani artikla Grupa
Default Price List,Zadani Cjenik
Default Price List Currency,Zadani Cjenik valuta
Default Print Format,Zadani Ispis Format
Default Product Category,Zadani Kategorija proizvoda
Default Purchase Account in which cost of the item will be debited.,Zadani Kupnja računa na koji trošak stavke će biti terećen.
Default Reserved Warehouse,Zadani Rezervirano galerija
Default Sales Partner,Zadani Prodaja partner
Default Settings,Tvorničke postavke
Default Source Warehouse,Zadani Izvor galerija
Default Stock UOM,Zadani kataloški UOM
Default Supplier Type,Zadani Dobavljač Tip
Default Target Warehouse,Zadani Ciljana galerija
Default Territory,Zadani Regija
Default Unit of Measure,Zadani Jedinica mjere
Default Valuation Method,Zadani metoda vrednovanja
Default Value,Zadana vrijednost
Default Warehouse Type,Zadani galerija Tip
Default values are set across the role and can be over-ridden by user permissions.,Zadane vrijednosti su postavili preko uloge i može biti više-oslobođenje od korisnika dozvole.
"Default: ""Product Search""",Default: &quot;Na Traži&quot;
DefaultValue,DefaultValue
Defaults,Zadani
"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Odredite proračun za ovu troška. Da biste postavili proračuna akciju, vidi <a href=""#!List/Company"">Tvrtka Master</a>"
Define Rule,Definiranje pravila
Defines actions on states and the next step and allowed roles.,Definira aktivnosti na članicama i sljedeći korak i dopušteni uloge.
Defines workflow states and rules for a document.,Definira tijeka stanja i pravila za dokument.
Delete,Izbrisati
Delivered,Isporučena
Delivered Items To Be Billed,Isporučena Stavke biti naplaćeno
Delivered Qty,Isporučena Kol
Delivery (shipment) to customers.,Dostava (pošiljka) kupcima.
Delivery Address,Dostava Adresa
Delivery Date,Dostava Datum
Delivery Details,Detalji o isporuci
Delivery Document No,Dostava Dokument br
Delivery Document Type,Dostava Document Type
Delivery Note,Obavještenje o primanji pošiljke
Delivery Note Item,Otpremnica artikla
Delivery Note Items,Način Napomena Stavke
Delivery Note Message,Otpremnica Poruka
Delivery Note No,Dostava Napomena Ne
Delivery Note Packing Item,Dostava Napomena Pakiranje artikla
Delivery Note Required,Dostava Napomena Obavezno
Delivery Status,Status isporuke
Delivery Time,Vrijeme isporuke
Department,Odsjek
Depend on LWP,Ovise o lwp
Depends On,Ovisi o
Depends on LWP,Ovisi o lwp
Descending,Spuštanje
Description,Opis
Description HTML,Opis HTML
Description of a Job Opening,Opis posla otvorenje
Desert,Pustinja
Designation,Oznaka
Desktop,Desktop
Detail Name,Detalj Ime
Detailed Breakup of the totals,Detaljni raspada ukupnim
Details,Detalji
Did not add.,Nije li dodati.
Did not cancel,Nije li otkazati
Did not save,Nije li spremiti
Difference,Razlika
"Different ""States"" this document can exist in. Like ""Open"", ""Pending Approval"" etc.","Različite &quot;Države&quot;, ovaj dokument može postojati u. Kao &quot;Otvoreno&quot;, &quot;na čekanju za odobrenje&quot;, itd."
Disabled,Onesposobljen
Disabled Filters,Invalidi pretrage
Discount  %,Popust%
Discount %,Popust%
Discount (%),Popust (%)
"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Popust Polja će biti dostupan u narudžbenice, Otkup primitka, Otkup fakturu"
Discount(%),Popust (%)
Display,Prikaz
Display Settings,Postavke prikaza
Display all the individual items delivered with the main items,Prikaži sve pojedinačne stavke isporučuju s glavnim stavkama
Distinct unit of an Item,Razlikovna jedinica stavku
Distribute transport overhead across items.,Podijeliti prijevoz pretek preko stavke.
Distribution Id,Distribucija Id
Distribution Name,Distribucija Ime
Distributor,Distributer
Divorced,Rastavljen
Do not show any symbol like $ etc next to currencies.,Ne pokazuju nikakav simbol kao $ itd uz valutama.
Doc Name,Doc Ime
Doc Status,Doc Status
Doc Type,Doc Tip
DocField,DocField
DocPerm,DocPerm
DocType,DOCTYPE
DocType Details,DOCTYPE Detalji
DocType Label,DOCTYPE oznaka
DocType Mapper,DOCTYPE Mapper
DocType is a Table / Form in the application.,DOCTYPE je tablica / Forma u primjeni.
DocType on which this Workflow is applicable.,DOCTYPE na koje se ovaj tijek je primjenjivo.
DocType or Field,DOCTYPE ili polja
Document,Dokument
Document Description,Dokument Opis
Document Status transition from ,Dokument Status prijelaz iz
Document Type,Document Type
Document is only editable by users of role,Dokument je samo uređivati ​​korisnika ulozi
Document to rename,Dokument za preimenovanje
Documentation,Dokumentacija
Documents,Dokumenti
Domain List,Domena Popis
Download Backup,Preuzmite Backup
Download Materials Required,Preuzmite Materijali za
Download Template,Preuzmite predložak
Download a report containing all raw materials with their latest inventory status,Preuzmite izvješće koje sadrži sve sirovine sa svojim najnovijim inventara statusa
Draft,Skica
Drafts,Nacrti
Drag to sort columns,Povuci za sortiranje stupaca
Due Date,Datum dospijeća
Duration,Trajanje
EMP/,EMP /
ESIC CARD No,ESIC KARTICA Ne
ESIC No.,ESIC broj
Earning,Zarada
Earning & Deduction,Zarada &amp; Odbitak
Earning Type,Zarada Vid
Earning1,Earning1
Edit,Uredi
Editable,Uređivati
Educational Qualification,Obrazovne kvalifikacije
Educational Qualification Details,Obrazovni Pojedinosti kvalifikacije
Eg. smsgateway.com/api/send_sms.cgi,Npr.. smsgateway.com / api / send_sms.cgi
Eligible Amount,Prihvatljivo Iznos
Email,E-mail
Email (By company),E-mail (Po mjestu)
Email Digest,E-pošta
Email Digest Settings,E-pošta Postavke
Email Host,E-mail Host
Email Id,E-mail ID
"Email Id must be unique, already exists for: ","E-mail Id mora biti jedinstvena, već postoji za:"
"Email Id where a job applicant will email e.g. ""jobs@example.com""",E-mail Id gdje posao zahtjeva će e-mail npr. &quot;jobs@example.com&quot;
Email Login,E-mail Prijava
Email Password,E-mail Lozinka
Email Sent,E-mail poslan
Email Sent?,E-mail poslan?
Email Settings,Postavke e-pošte
Email Settings for Outgoing and Incoming Emails.,Postavke e-pošte za odlazne i dolazne e-pošte.
Email Signature,E-mail potpis
Email Use SSL,Pošaljite Use
"Email addresses, separted by commas","E-mail adrese, separted zarezom"
"Email settings for jobs email id ""jobs@example.com""",E-mail postavke za poslove email id &quot;jobs@example.com&quot;
"Email settings to extract Leads from sales email id e.g. ""sales@example.com""",E-mail postavke za izdvajanje vodi od prodaje email id npr. &quot;sales@example.com&quot;
Embed image slideshows in website pages.,Postavi slikovne prezentacije u web stranicama.
Emergency Contact Details,Hitna Kontaktni podaci
Emergency Phone Number,Hitna Telefonski broj
Employee,Zaposlenik
Employee Designation.,Zaposlenik Imenovanje.
Employee Details,Zaposlenih Detalji
Employee Education,Zaposlenik Obrazovanje
Employee External Work History,Zaposlenik Vanjski Rad Povijest
Employee Internal Work History,Zaposlenik Unutarnji Rad Povijest
Employee Internal Work Historys,Zaposlenih unutarnji rad Historys
Employee Name,Zaposlenik Ime
Employee Number,Zaposlenik Broj
Employee Records to be created by ,Zaposlenih Zapisi se stvorio
Employee Setup,Zaposlenik konfiguracija
Employee Training,Zaposlenik Trening
Employee Type,Zaposlenik Tip
Employee grades,Zaposlenih razreda
Employee record is created using selected field. ,Zaposlenik rekord je stvorena pomoću odabranog polja.
Employee records.,Zaposlenih evidencija.
Employees Email Id,Zaposlenici Email ID
Employment Details,Zapošljavanje Detalji
Employment Type,Zapošljavanje Tip
Enable / disable currencies.,Omogućite / onemogućite valute.
Enabled,Omogućeno
Enables <b>More Info.</b> in all documents,Omogućuje <b>Vise Informacija.</b> U svim dokumentima
Encashment Date,Encashment Datum
End Date,Datum završetka
End date of current invoice's period,Kraj datum tekućeg razdoblja dostavnice
End of Life,Kraj života
Ends on,Završava
Enter Email Id to receive Error Report sent by users.E.g.: support@iwebnotes.com,Unesite Email ID primiti izvješće o pogrešci poslao users.Eg: support@iwebnotes.com
Enter Form Type,Unesite Obrazac Vid
Enter Row,Unesite Row
Enter campaign name if the source of lead is campaign.,Unesite naziv kampanje ukoliko izvor olova je kampanja.
"Enter default value fields (keys) and values. If you add multiple values for a field, the first one will be picked. These defaults are also used to set ""match"" permission rules. To see list of fields, go to <a href=""#Form/Customize Form/Customize Form"">Customize Form</a>.","Unesite polja zadane vrijednosti (ključevi) i vrijednosti. Ako ste dodali više vrijednosti za polje, prvi će se podići. Ove postavke su također koristi za postavljanje &quot;match&quot; dozvola pravila. Da biste vidjeli popis polja, idite na <a href=""#Form/Customize Form/Customize Form"">Prilagodi obrazac</a> ."
Enter department to which this Contact belongs,Unesite odjel na koji se ovaj Kontakt pripada
Enter designation of this Contact,Upišite oznaku ove Kontakt
"Enter domain names associated to this website, each on a new line","Unesite imena domena povezane s ovim stranicama, svaki na novoj liniji"
"Enter email id separated by commas, invoice will be mailed automatically on particular date","Unesite e-mail ID odvojena zarezima, račun će automatski biti poslan na određeni datum"
Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Unesite stavke i planirani Količina za koje želite povećati proizvodne naloge ili preuzimanje sirovine za analizu.
Enter message,Unesite poruku
Enter name of campaign if source of enquiry is campaign,"Unesite naziv kampanje, ako je izvor upit je kampanja"
"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Unesite statičke parametre URL ovdje (npr. pošiljatelj = ERPNext, username = ERPNext, lozinkom = 1234 itd.)"
Enter the company name under which Account Head will be created for this Supplier,Unesite naziv tvrtke pod kojima računa Voditelj će biti stvoren za tu dobavljača
Enter the date by which payments from customer is expected against this invoice.,Unesite datum do kojeg isplate kupca se očekuje protiv ovog računa.
Enter url parameter for message,Unesite URL parametar za poruke
Enter url parameter for receiver nos,Unesite URL parametar za prijemnike br
Entries,Prijave
Entries are not allowed against this Fiscal Year if the year is closed.,"Prijave nisu dozvoljeni protiv ove fiskalne godine, ako se godina zatvoren."
Error,Pogreška
Estimated Material Cost,Procjena troškova materijala
Event,Događaj
Event Individuals,Događaj Pojedinci
Event Role,Događaj Uloga
Event Roles,Događaj Uloge
Event Type,Vrsta događaja
Event Updates,Događaj ažuriranja
Event User,Događaj Upute
Exchange Rate,Tečaj
Excise Page Number,Trošarina Broj stranice
Excise Voucher,Trošarina bon
Execute,Izvršiti
Exemption Limit,Izuzeće granica
Exhibition,Izložba
Existing Customer,Postojeći Kupac
Exit,Izlaz
Exit Interview Details,Izlaz Intervju Detalji
Expected,Očekivana
Expected Delivery Date,Očekivani rok isporuke
Expected End Date,Očekivani Datum završetka
Expected Start Date,Očekivani datum početka
Expense Account,Rashodi račun
Expense Claim,Rashodi polaganja
Expense Claim Approved,Rashodi Zahtjev odobren
Expense Claim Approved Message,Rashodi Zahtjev Odobren poruku
Expense Claim Detail,Rashodi Zahtjev Detalj
Expense Claim Details,Rashodi Pojedinosti o polaganju
Expense Claim Rejected,Rashodi Zahtjev odbijen
Expense Claim Rejected Message,Rashodi Zahtjev odbijen poruku
Expense Claim Type,Rashodi Vrsta polaganja
Expense Date,Rashodi Datum
Expense Details,Rashodi Detalji
Expense Head,Rashodi voditelj
Expenses Booked,Rashodi Rezervirani
Expiry Date,Datum isteka
Export,Izvoz
Exports,Izvoz
External,Vanjski
Extra Condition,Dodatni hotela
Extract Emails,Ekstrakt e-pošte
Extract Job Applicant from jobs email id e.g. jobs@example.com,Ekstrakt posao podnositelja zahtjeva iz radnih email id npr. jobs@example.com
Extract Leads from sales email id e.g. sales@example.com,Ekstrakt vodi od prodaje email id npr. sales@example.com
FCFS Rate,FCFS Stopa
FIFO,FIFO
Family Background,Obitelj Pozadina
FavIcon,Favicon
Fax,Fax
Featured Item,Prikazan artikla
Featured Item in Item Group,Prikazan artikla u točki Grupe
Features Setup,Značajke konfiguracija
Feed,Hraniti
Feed Type,Pasi Vid
Feedback,Povratna veza
Female,Ženski
Fetch lead which will be converted into customer.,Fetch vodstvo koje će se pretvoriti u kupca.
Field,Polje
Field Description,Opis polja
Field Mapper Detail,Polje Mapper Detalj
Field Mapper Details,Terenska Mapper Detalji
Field Name,Naziv polja
Field Type,Vrsta polja
"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Polje dostupan u otpremnicu, ponudu, prodaje fakture, prodaja reda"
Field from other forms,Područje od drugih oblika
"Field that represents the Workflow State of the transaction (if field is not present, a new hidden Custom Field will be created)","Područje koje predstavlja tijeka državu transakcije (ako polje nije prisutan, novi skriveno Custom Field će biti stvoren)"
Fieldname,"Podataka, Naziv Polja"
Fields,Polja
"Fields separated by comma (,) will be included in the<br /><b>Search By</b> list of Search dialog box","Polja odvojene zarezom (,) će biti uključen u <br /> <b>Traži po</b> popisu Pretraživanje dijaloškom okviru"
File Data,File Podaci
File LIst,Popis datoteka
File List,Popis datoteka
File Name,File Name
File URL,URL datoteke
File Uploaded Sucessfully.,Datoteka Snimljeno uspješno.
Filing in Additional Information about the Opportunity will help you analyze your data better.,Podnošenje u dodatne informacije o Prilika će vam pomoći da analizirati podatke bolje.
Filing in Additional Information about the Purchase Receipt will help you analyze your data better.,Podnošenje u dodatne informacije o kupoprodaji prijemu će vam pomoći da analizirati podatke bolje.
Filing in Additional Information about the Purchase Requisition will help you analyze your data better.,Podnošenje u dodatne informacije o kupoprodaji rekvizicije će vam pomoći da analizirati podatke bolje.
Filling in Additional Information about the Delivery Note will help you analyze your data better.,Ispunjavanje Dodatne informacije o otpremnici će vam pomoći da analizirati podatke bolje.
Filling in additional information about the Quotation will help you analyze your data better.,Ispunjavanje dodatne informacije o kotaciju će vam pomoći da analizirati podatke bolje.
Filling in additional information about the Sales Order will help you analyze your data better.,Ispunjavanje dodatne informacije o prodaji Reda će vam pomoći da analizirati podatke bolje.
Filter By Amount,Filtriraj po visini
Filter By Date,Filter By Date
Filter based on customer,Filter temelji se na kupca
Filter based on item,Filtrirati na temelju točki
Filters,Filteri
Final Confirmation Date,Konačna potvrda Datum
Financial Analytics,Financijski Analytics
Financial Statements,Financijska izvješća
Financial Years for books of accounts,Financijska godina za knjigama računa
First Name,Ime
First Responded On,Prvo Odgovorili Na
Fiscal Year,Fiskalna godina
Fiscal Year Details,Fiskalna godina Detalji
Fixed Asset Account,Dugotrajne imovine račun
Float,Plutati
Float Precision,Float Precision
Floral,Cvijetan
Following dates are blocked for Leave,Nakon datumi su blokirani dopusta
"Following table will show values if items are sub - contracted. These values will be fetched from the master of ""Bill of Materials"" of sub - contracted items.",Nakon stol će pokazati vrijednosti ako su stavke pod - ugovoreno. Ove vrijednosti će biti preuzeta od zapovjednika &quot;Bill of Materials&quot; pod - ugovoreni stavke.
Font,Krstionica
Font Size,Veličina fonta
Footer,Footer
Footer Items,Footer Proizvodi
For All Users,Za sve korisnike
For Buying,Za kupnju
For Company,Za tvrtke
For Employee,Za zaposlenom
For Employee Name,Za ime zaposlenika
For Item ,Za točku
"For Links, enter the DocType as rangeFor Select, enter list of Options separated by comma","Za Linkovi, unesite DOCTYPE kao rangeFor Select, unesite popisu opcija odvojenih zarezom"
"For Links, use define linked","Za Linkovi, koristite definirati povezani"
For Production,Za proizvodnju
For Reference Only.,Samo za referencu.
For Selling,Za prodaju
For Warehouse,Za galeriju
"For comparative filters, start with","Za komparativne filtera, početi s"
"For e.g. 2012, 2012-13","Za npr. 2012, 2012-13"
For example if you cancel and amend 'INV004' it will become a new document 'INV004-1'. This helps you to keep track of each amendment.,"Na primjer, ako ste odustali i dopune &#39;INV004&#39; postat će novi dokument &#39;INV004-1&#39;. To vam pomaže pratiti svaku izmjenu i dopunu."
For example: You want to restrict users to transactions marked with a certain property called 'Territory',Na primjer: Vi želite ograničiti korisnike transakcija označena s određenom objektu koji se zove &#39;teritorij&#39;
For opening balance entry account can not be a PL account,Za otvaranje računa bilance ulaz ne može biti PL račun
"For opening invoice entry, this date will reflect in the period-wise aging report.","Za otvaranje računa ulazak, ovaj datum će se odraziti na razdoblje-mudar starenja izvješću."
For ranges,Za raspone
For reference,Za referencu
For reference only.,Za samo kao referenca.
"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Za praktičnost kupaca, te kodovi mogu se koristiti u tiskanim formata kao što su fakture i otpremnice"
Form,Oblik
Format: hh:mm example for one hour expiry set as 01:00. Max expiry will be 72 hours. Default is 24 hours,Format: hh: mm primjer za jedan sat isteka postavljen kao 01:00. Maks isteka će biti 72 sati. Default je 24 sati
Forum,Forum
Fraction,Frakcija
Fraction Units,Frakcije Jedinice
Friday,Petak
From Company,Iz Društva
From Customer,Od kupca
From Date,Od datuma
From Date must be before To Date,Od datuma mora biti prije do danas
From DocType,Od DOCTYPE
From Employee,Od zaposlenika
From Field,Od Field
From PR Date,Iz PR Datum
From Package No.,Iz paketa broj
From Table,Iz tablice
Frozen,Zaleđeni
Full Image,Cijeli slike
Full Name,Ime i prezime
Full description (formatted as markdown),Cijeli opis (formatiran kao smanjenje)
Fully Billed,Potpuno Naplaćeno
Fully Completed,Potpuno Završeni
GL Control,GL kontrola
GL Entry,GL Stupanje
GL Entry: Debit or Credit amount is mandatory for ,GL Stupanje: itnim iznos je obavezna za
GL Mapper,GL Mapper
GL Mapper Detail,GL Mapper Detalj
GRN,GRN
Gantt Chart,Gantogram
Gantt chart of all tasks.,Gantogram svih zadataka.
Gender,Rod
General,Opći
General Ledger,Glavna knjiga
Generate Description HTML,Generiranje Opis HTML
Generate Material Requests (MRP) and Production Orders.,Generirajte Materijal Upiti (MRP) i radne naloge.
Generate Salary Slips,Generiranje plaće gaćice
Generate Schedule,Generiranje Raspored
"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generirajte pakiranje gaćice za pakete koji će biti isporučen. Rabljeni obavijestiti paket broj, sadržaj paketa i njegovu težinu."
Generates HTML to include selected image in the description,Stvara HTML uključuju odabrane slike u opisu
Georgia,Gruzija
Get Advances Paid,Nabavite plaćenim avansima
Get Advances Received,Get Napredak pozicija
Get Current Stock,Nabavite trenutne zalihe
Get Items,Nabavite artikle
Get Last Purchase Rate,Nabavite Zadnji Ocijeni Kupnja
Get Non Reconciled Entries,Get Non pomirio tekstova
Get Open Sales Order,Nabavite Otvori prodajnog naloga
Get Outstanding Invoices,Nabavite neplaćene račune
Get Purchase Receipt,Get Kupnja Račun
Get Sales Orders,Nabavite narudžbe
Get Specification Details,Nabavite Specifikacija Detalji
Get Stock and Rate,Nabavite Stock i stopa
Get Tax Detail,Nabavite poreza Detalj
Get Taxes and Charges,Nabavite porezi i pristojbe
Get Template,Nabavite predloška
Get Terms and Conditions,Nabavite Uvjeti i pravila
Get Weekly Off Dates,Nabavite Tjedno Off datumi
Get the template of the Attendance for which you want to import in CSV (Comma seperated values) format.Fill data in the template. Save the template in CSV format.All attendance dates inbetween 'Attendance From Date' and 'Attendance To Date' will come in the template with employees list.,Nabavite slikovni Gledatelji za koje želite uvesti u CSV (vrijednosti odvojenih zarezom) format.Fill podataka u predložak. Spremi predložak u CSV format.All prisustvo datira između ta dva &#39;Gledatelji od datuma&#39; i &#39;posjećenost do danas&#39; će doći u predlošku sa zaposlenicima popisu.
"Get valuation rate and available stock at source/target warehouse on mentioned posting date-time. If serialized item, please press this button after entering serial nos.","Nabavite stopa za vrednovanje i dostupni zaliha na izvor / cilj skladištu na spomenuti datum knjiženja radno vrijeme. Ako serijaliziranom stavku, molimo pritisnite ovu tipku nakon ulaska serijskih brojeva."
Global Defaults,Globalni Zadano
Go back to home,Vrati se kući
Go to Setup > <a href='#user-properties'>User Properties</a> to set \			'territory' for diffent Users.,Idite na Setup&gt; <a href='#user-properties'>Svojstva korisnika</a> za postavljanje \ &#39;teritorij&#39; za diffent korisnike.
Goal,Cilj
Goals,Golovi
Goods received from Suppliers.,Roba dobio od dobavljače.
Grade,Razred
Graduate,Diplomski
Grand Total,Sveukupno
Grand Total (Export),Sveukupno (izvoz)
Grand Total (Import),Sveukupno (Uvoz)
Grand Total*,Sveukupno *
Gratuity LIC ID,Poklon LIC ID
Gross Margin %,Bruto marža%
Gross Margin Value,Bruto marža vrijednost
Gross Pay,Bruto plaće
Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Bruto plaće + + zaostatak Iznos Iznos Encashment - Ukupno Odbitak
Gross Profit,Ukupan profit
Gross Profit (%),Bruto dobit (%)
Gross Weight,Bruto težina
Gross Weight UOM,Bruto težina UOM
Group,Grupa
Group By,Grupa Do
Group or Ledger,Grupa ili knjiga
Groups,Grupe
HR,HR
HTML,HTML
HTML / Banner that will show on the top of product list.,HTML / bannera koji će se prikazivati ​​na vrhu liste proizvoda.
"HTML print formats for quotes, invoices etc","HTML ispis formata za citati, fakture, itd."
Half Day,Pola dana
Half Yearly,Pola Godišnji
Half-yearly,Polugodišnje
Has Batch No,Je Hrpa Ne
Has Child Node,Je li čvor dijete
Has Serial No,Ima Serial Ne
Header,Kombajn
Heading,Naslov
Heading Font,Naslov font
Heads (or groups) against which Accounting Entries are made and balances are maintained.,Šefovi (ili skupine) protiv kojih Računovodstvo upisi su izrađene i sredstva su održavani.
Health Concerns,Zdravlje Zabrinutost
Health Details,Zdravlje Detalji
Held On,Održanoj
Help,Pomoći
Help HTML,Pomoć HTML
Helper for managing return of goods (sales or purchase),Pomoćnik za upravljanje povrat robe (prodaja ili kupnja)
Helvetica Neue,Helvetica Neue
"Hence, maximum allowed Manufacturing Quantity","Dakle, maksimalno dopuštena količina proizvodnje"
"Here you can maintain family details like name and occupation of parent, spouse and children","Ovdje možete održavati obiteljske pojedinosti kao što su ime i okupacije roditelja, supružnika i djecu"
"Here you can maintain height, weight, allergies, medical concerns etc","Ovdje možete održavati visina, težina, alergije, medicinske brige itd."
Hey there! You need to put at least one item in \				the item table.,Hej tamo! Vi trebate da stavite barem jednu stavku u \ tablicu artikala.
Hey! You seem to be using the wrong template. \				Click on 'Download Template' button to get the correct template.,Hej! Čini se da se pomoću krivi predložak. \ Kliknite na &#39;Download predložak&#39; gumb da biste dobili ispravan predložak.
Hidden,Skriven
Hide Actions,Sakrij Akcije
Hide Copy,Sakrij Copy
Hide Currency Symbol,Sakrij simbol valute
Hide Email,Sakrij e
Hide Heading,Sakrij Naslov
Hide Print,Sakrij Ispis
Hide Toolbar,Sakrij alatne trake
High,Visok
Highlight,Istaknuti
History In Company,Povijest U Društvu
Hold,Držati
Holiday,Odmor
Holiday Block List,Turistička Blok Popis
Holiday Block List Allow,Turistička Popis Blok Dopustite
Holiday Block List Allowed,Turistička Blok Popis dopuštenih
Holiday Block List Date,Turistička Blok Popis Datum
Holiday Block List Dates,Holiday Block List datumi
Holiday Block List Name,Turistička Blok Popis Ime
Holiday List,Turistička Popis
Holiday List Name,Turistička Popis Ime
Holidays,Praznici
Home,Dom
Home Control,Početna kontrola
Home Page,Početna stranica
Home Page is Products,Početna stranica je proizvodi
Home Pages,Početna stranica
Host,Domaćin
"Host, Email and Password required if emails are to be pulled","Domaćin, e-mail i lozinka potrebni ako e-mailove su se izvukao"
Hour Rate,Sat Ocijenite
Hour Rate Consumable,Sat Ocijenite Potrošni
Hour Rate Electricity,Sat Ocijenite Struja
Hour Rate Labour,Sat Ocijenite rada
Hour Rate Rent,Sat Ocijenite Najam
Hours,Sati
How frequently?,Kako često?
"How should this currency be formatted? If not set, will use system defaults","Kako bi se to valuta biti formatiran? Ako nije postavljeno, koristit će zadane postavke sustava"
How to upload,Kako prenijeti
Hrvatski,Hrvatski
Human Resources,Ljudski resursi
Human Resources Home,Ljudski resursi Home
Hurray! The day(s) on which you are applying for leave \					coincide with holiday(s). You need not apply for leave.,Ura! Dan (e) na koje se prijavljuje za ostaviti \ podudara s odmora (s). Vi ne trebate podnijeti zahtjev za dopust.
I,Ja
ID (name) of the entity whose property is to be set,ID (ime) subjekta čiji je objekt se postaviti
IDT,IDT
IGHelp,IGHelp
II,II
III,III
IN,U
INV,INV
INV/10-11/,INV/10-11 /
IV,IV
Icon,Ikona
Icon will appear on the button,Ikona će se pojaviti na gumb
Id of the profile will be the email.,Id profilu će biti e-mail.
Identification of the package for the delivery (for print),Identifikacija paketa za dostavu (za tisak)
If Monthly Budget Exceeded,Ako Mjesečni proračun Exceeded
"If Sale BOM is defined, the actual BOM of the Pack is displayed as table.Available in Delivery Note and Sales Order","Ako Prodaja BOM definiran, stvarna BOM od Pack prikazuje se kao table.Available u otpremnici i prodajnog naloga"
"If Supplier Part Number exists for given Item, it gets stored here","Ako Dobavljač Broj dijela postoji za određeni predmet, to dobiva pohranjen ovdje"
If Yearly Budget Exceeded,Ako Godišnji proračun Exceeded
"If a User does not have access at Level 0, then higher levels are meaningless","Ako korisnik ne imati pristup na razini 0, onda je viša razina su besmislene"
"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Ako je označeno, BOM za pod-zbor stavke će biti uzeti u obzir za dobivanje sirovine. Inače, sve pod-montaža stavke će biti tretirani kao sirovinu."
"If checked, all other workflows become inactive.","Ako je označeno, svi ostali tijekovi postaju neaktivne."
"If checked, the Home page will be the default Item Group for the website.","Ako je označeno, stranica Home će biti zadana Grupa za web stranice predmeta."
"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Ako je označeno, iznos poreza će se smatrati već uključena u Print Rate / Ispis Iznos"
"If image is selected, color will be ignored (attach first)","Ako je slika odabrana, boja će biti ignoriran (priložiti prvi)"
If more than one package of the same type (for print),Ako je više od jedan paket od iste vrste (za tisak)
If non standard port (e.g. 587),Ako ne standardni ulaz (npr. 587)
If not applicable please enter: NA,Ako ne odnosi unesite: NA
"If not checked, the list will have to be added to each Department where it has to be applied.","Ako nije označeno, popis će biti dodan u svakom odjela gdje se mora primjenjivati."
"If not, create a","Ako ne, stvoriti"
"If set, data entry is only allowed for specified users. Else, entry is allowed for all users with requisite permissions.","Ako skup, unos podataka je dopušteno samo za određene korisnike. Inače, ulaz je dozvoljen za sve korisnike sa potrebnim dozvolama."
"If specified, send the newsletter using this email address","Ako je navedeno, pošaljite newsletter koristeći ovu e-mail adresu"
"If the 'territory' Link Field exists, it will give you an option to select it","Ako &#39;teritoriju&#39; Link Polje postoji, to će vam dati mogućnost da ga odabrali"
"If the account is frozen, entries are allowed for the ""Account Manager"" only.","Ako je račun zamrznut, unosi su dozvoljeni za &quot;Account Manager&quot; jedini."
"If this Account represents a Customer, Supplier or Employee, set it here.","Ako se to računa predstavlja kupac, dobavljač ili zaposlenik, postavite ga ovdje."
If you follow Quality Inspection<br>Enables item QA Required and QA No in Purchase Receipt,Ako slijedite Inspekcija kvalitete <br> Omogućuje stavku QA potrebno i QA nema u kupoprodaji primitka
If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,Ako imate prodajnog tima i prodaja partnerima (partneri) mogu biti označene i održavati svoj doprinos u prodajne aktivnosti
"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.","Ako ste stvorili standardni predložak za kupnju poreze i pristojbe magisterij, odaberite jednu i kliknite na gumb ispod."
"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Ako ste stvorili standardni predložak u prodaji poreze i pristojbe magisterij, odaberite jednu i kliknite na gumb ispod."
"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Ako ste dugo ispis formata, ova značajka može se koristiti za podijeliti stranicu na koju se ispisuje više stranica sa svim zaglavljima i podnožjima na svakoj stranici"
If you involve in manufacturing activity<br>Enables item <b>Is Manufactured</b>,Ako uključiti u proizvodnju aktivnosti <br> Omogućuje predmet <b>je proizveden</b>
Ignore,Ignorirati
Image,Slika
Image View,Slika Pogledaj
Image for listing (Width: 100px) (Attach First),Slika za uvrštenje (Širina: 100px) (Priložiti Prvo)
Image for listing (Width: 300px) (Attach First),Slika za uvrštenje (Širina: 300 x) (Priložiti Prvo)
Implementation Partner,Provedba partner
Import,Uvoz
Import Date Format ,Uvoz Datum Format
Import Log,Uvoz Prijavite
Import Log1,Uvoz Log1
Import data from spreadsheet (csv) files,Uvoz podataka iz proračunske tablice (CSV) datoteka
Important dates and commitments in your project life cycle,Važni datumi i obveze u svoj ciklus projekta života
Imports,Uvoz
In Dialog,U Dialog
In Filter,U filtru
In List View,U prikazu popisa
In Process,U procesu
In Report Filter,U Prijavi Filter
In Store,U trgovini
In Words,U riječi
In Words (Export),U riječi (izvoz)
In Words (Export) will be visible once you save the Delivery Note.,U riječi (izvoz) će biti vidljiv nakon što spremite otpremnici.
In Words (Import),U riječi (Uvoz)
In Words will be visible once you save the Delivery Note.,U riječi će biti vidljiv nakon što spremite otpremnici.
In Words will be visible once you save the Purchase Invoice.,U riječi će biti vidljiv nakon što spremite ulazne fakture.
In Words will be visible once you save the Purchase Order.,U riječi će biti vidljiv nakon što spremite narudžbenice.
In Words will be visible once you save the Purchase Receipt.,U riječi će biti vidljiv nakon što spremite kupiti primitka.
In Words will be visible once you save the Quotation.,U riječi će biti vidljiv nakon što spremite ponudu.
In Words will be visible once you save the Sales Invoice.,U riječi će biti vidljiv nakon što spremite prodaje fakture.
In Words will be visible once you save the Sales Order.,U riječi će biti vidljiv nakon što spremite prodajnog naloga.
In Words(Import),U riječi (Uvoz)
In response to,U odgovoru na
"In the Permission Manager, click on the button in the 'Condition' column for the Role you want to restrict.","U dozvole Manager, kliknite na gumb u &#39;hotela&#39; stupcu za ulogu želite ograničiti."
Inactive,Neaktivan
Incentives,Poticaji
Incharge Name,Incharge Name
Income,Dohodak
Income Account,Prihodi račun
Income Year to Date,Prihodi godine do danas
Incoming,Dolazni
Incoming Mail Setting,Dolaznu poštu Podešavanje
Incoming Rate,Dolazni Stopa
Incoming Time,Dolazni Vrijeme
Incoming quality inspection.,Dolazni kvalitete inspekcije.
Indent,Uvući
Index,Indeks
Indicates that the package is a part of this delivery,Ukazuje na to da je paket dio ovog poroda
Individual,Pojedinac
Individuals,Pojedinci
Industry,Industrija
Industry Type,Industrija Tip
Info,Info
Insert After,Umetni Nakon
Insert Code,Umetnite kod
Insert Style,Umetni stil
Inspected By,Pregledati
Inspection Criteria,Inspekcijski Kriteriji
Inspection Required,Inspekcija Obvezno
Inspection Type,Inspekcija Tip
Installation Date,Instalacija Datum
Installation Note,Instalacija Napomena
Installation Note Item,Instalacija Napomena artikla
Installation Status,Instalacija Status
Installation Time,Instalacija Vrijeme
Installation record for a Serial No.,Instalacija rekord za serijski broj
Installed Qty,Instalirani Kol
Institute / Conducted By,Institut / provela
Instructions,Instrukcije
Int,Interesi
Interested,Zainteresiran
Internal,Interni
Intro HTML,Uvod HTML
Introduce your company to the website visitor.,Uvesti svoju tvrtku za web stranice posjetitelja.
Introduction,Uvod
Introductory information for the Contact Us Page,Uvodni podaci za kontaktiranje stranice
Invalid Email Address,Neispravan e-mail adresu
Inventory,Inventar
Inverse,Inverzan
Invoice Date,Račun Datum
Invoice Details,Pojedinosti dostavnice
Invoice No,Račun br
Invoice Period From Date,Račun Razdoblje od datuma
Invoice Period To Date,Račun razdoblju do datuma
Is Active,Je aktivna
Is Advance,Je Predujam
Is Asset Item,Je imovinom artikla
Is Cancelled,Je Otkazan
Is Carry Forward,Je Carry Naprijed
Is Child Table,Je Dijete Tablica
Is Default,Je Default
Is Encash,Je li unovčiti
Is LWP,Je lwp
Is Mandatory Field,Je Obvezno polje
Is Opening,Je Otvaranje
Is PL Account,Je PL račun
Is POS,Je POS
Is Primary Address,Je Osnovna adresa
Is Primary Contact,Je Primarna Kontakt
Is Purchase Item,Je Kupnja artikla
Is Sales Item,Je Prodaja artikla
Is Service Item,Je li usluga artikla
Is Shipping Address,Je Dostava Adresa
Is Single,Je Samac
Is Standard,Je Standardni
Is Stock Item,Je kataloški artikla
Is Sub Contracted Item,Je Sub Ugovoreno artikla
Is Subcontracted,Je podugovarati
Is Submittable,Je Submittable
Is it a Custom DocType created by you?,Je li Custom DOCTYPE stvorio vas?
Is this Tax included in Basic Rate?,Je li ovo pristojba uključena u osnovne stope?
Issue,Izdanje
Issue Date,Datum izdavanja
Issue Details,Issue Detalji
Item,Stavka
Item Advanced,Stavka Napredna
Item Barcode,Stavka Barkod
Item Batch Nos,Stavka Batch Nos
Item Classification,Stavka klasifikacija
Item Code,Stavka Šifra
Item Customer Detail,Stavka Kupac Detalj
Item Description,Stavka Opis
Item Desription,Stavka Desription
Item Details,Stavka Detalji
Item Group,Stavka Grupa
Item Group Name,Stavka Ime grupe
Item Groups in Details,Stavka Grupe u detaljima
Item Image (if not slideshow),Stavka slike (ako ne Slideshow)
Item Name,Stavka Ime
Item Price,Stavka Cijena
Item Prices,Stavka Cijene
Item Quality Inspection Parameter,Stavka Provera kvaliteta parametara
Item Reorder,Stavka redoslijeda
Item Serial No,Stavka rednim brojem
Item Serial Nos,Stavka Serijski br
Item Supplier,Stavka Dobavljač
Item Supplier Details,Stavka Supplier Detalji
Item Tax,Stavka poreza
Item Tax Amount,Stavka Iznos poreza
Item Tax Rate,Stavka Porezna stopa
Item Tax1,Stavka Tax1
Item To Manufacture,Stavka za proizvodnju
Item UOM,Stavka UOM
Item Website Specification,Stavka Web Specifikacija
Item Website Specifications,Stavka Website Specifikacije
Item Wise Tax Detail ,Stavka Wise Porezna Detalj
Item classification.,Stavka klasifikacija.
Item to be manufactured or repacked,Stavka biti proizvedeni ili prepakirani
Item will be saved by this name in the data base.,Stavka će biti spremljena pod ovim imenom u bazi podataka.
"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Stavka, jamstvo, AMC (Godišnje održavanje Ugovor) pojedinosti će biti automatski dohvatio kada serijski broj je odabran."
Item-Wise Price List,Stavka-Wise Cjenik
Item: ',Stavka: &#39;
Items,Proizvodi
"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty",Proizvodi se traži što su &quot;Out of Stock&quot; s obzirom na sve skladišta na temelju projicirane Qty i minimalne narudžbe Kol
Items which do not exist in Item master can also be entered on customer's request,Proizvodi koji ne postoje u artikla gospodara također može unijeti na zahtjev kupca
Itemwise Discount,Itemwise Popust
JSON,JSON
JV,JV
Javascript,Javascript
Javascript to append to the head section of the page.,Javascript da doda glave dijelu stranice.
Job Applicant,Posao podnositelj
Job Opening,Posao Otvaranje
Job Profile,Posao Profil
Job Title,Titula
"Job profile, qualifications required etc.","Posao profil, kvalifikacije potrebne, itd."
Jobs Email Settings,Poslovi Postavke e-pošte
Journal Entries,Časopis upisi
Journal Entry,Časopis Stupanje
Journal Voucher,Časopis bon
Journal Voucher Detail,Časopis bon Detalj
Journal Voucher Detail No,Časopis bon Detalj Ne
KRA,KRA
"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Držati Trag od prodaje kampanje. Pratite vodi, citati, prodaja reda itd. iz kampanje radi vrjednovanja povrat na investiciju."
Keep a track of all communications,Držite praćenje svih komunikacija
Keep a track of communication related to this enquiry which will help for future reference.,Držite pratiti komunikacije vezane uz ovaj upit koji će vam pomoći za buduću referencu.
Keep a track on communications regarding this Quotation. This will help you remember earlier communications in case the Customer comes back again,Držite pratiti na komunikaciju u vezi ovog ponudu. To će vam pomoći da zapamtite ranije komunikacije u slučaju Kupac dolazi natrag
Key,Ključ
Key Performance Area,Key Performance Area
Key Responsibility Area,Ključ Odgovornost Površina
Knowledge Base,Baza znanja
LEAD,OLOVO
LEAD/10-11/,LEAD/10-11 /
LEAD/MUMBAI/,OLOVO / MUMBAI /
LR Date,LR Datum
LR No,LR Ne
Label,Oznaka
Label Help,Oznaka Pomoć
Lacs,Lacs
Landed Cost Item,Sletio Troškovi artikla
Landed Cost Items,Sletio troškova Proizvodi
Landed Cost Purchase Receipt,Sletio Trošak Kupnja Potvrda
Landed Cost Purchase Receipts,Sletio troškova kupnje Primici
Landed Cost Wizard,Sletio Trošak Čarobnjak
Landing Page,Odredišna stranica
Language,Jezik
Language preference for user interface (only if available).,Jezik sklonost za korisničko sučelje (samo ako je dostupan).
Last Contact Date,Zadnji kontakt Datum
Last IP,Posljednja IP
Last Login,Zadnji Login
Last Modified On,Zadnji put na
Last Name,Prezime
Last Purchase Rate,Zadnja Kupnja Ocijenite
Last Update,Zadnja promjena
Last Update By,Zadnji Update
Latest Updates,Najnovija ažuriranja
Lato,Lato
Lead,Dovesti
Lead Details,Olovo Detalji
Lead Lost,Olovo Lost
Lead Name,Olovo Ime
Lead Owner,Olovo Vlasnik
Lead Ref,Olovo Ref.
Lead Source,Olovo Source
Lead Status,Olovo Status
Lead Time Date,Olovo Time Date
Lead Time Days,Olovo vrijeme Dane
Lead Time days is number of days by which this item is expected in your warehouse. This days is fetched in Material Request when you select this item.,Olovo vrijeme dana je broj dana koji ovaj predmet se očekuje u skladištu. Ovih dana je preuzeta u Materijal Zahtjev kada odaberete ovu stavku.
Lead Type,Olovo Vid
Leave Allocation,Ostavite Raspodjela
Leave Allocation Tool,Ostavite raspodjele alat
Leave Application,Ostavite aplikaciju
Leave Approver,Ostavite odobravatelju
Leave Balance Before Application,Ostavite Balance Prije primjene
Leave Block List,Ostavite Block List
Leave Block List Allow,Ostavite Blok Popis Dopustite
Leave Block List Allowed,Ostavite Block List dopuštenih
Leave Block List Date,Ostavite Date Popis Block
Leave Block List Dates,Ostavite datumi lista blokiranih
Leave Block List Name,Ostavite popis imena Block
Leave Blocked,Ostavite blokirani
Leave Control Panel,Ostavite Upravljačka ploča
Leave Encashed?,Ostavite Encashed?
Leave Encashment Amount,Ostavite Encashment Iznos
Leave Setup,Ostavite Setup
Leave Type,Ostavite Vid
Leave Type Name,Ostavite ime tipa
Leave Without Pay,Ostavite bez plaće
Leave allocations.,Ostavite izdvajanja.
Leave blank if considered for all branches,Ostavite prazno ako smatra za sve grane
Leave blank if considered for all departments,Ostavite prazno ako smatra za sve odjele
Leave blank if considered for all designations,Ostavite prazno ako smatra za sve oznake
Leave blank if considered for all employee types,Ostavite prazno ako smatra za sve tipove zaposlenika
Leave blank if considered for all grades,Ostavite prazno ako smatra za sve razrede
Leave by,Ostavite po
"Leave can be approved by users with Role, ""Leave Approver""","Ostavite može biti odobren od strane korisnika s uloge, &quot;Ostavite odobravatelju&quot;"
Ledger,Glavna knjiga
Left,Lijevo
Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Pravna osoba / Podružnica s odvojenim kontnom planu pripadaju organizaciji.
Letter Head,Pismo Head
Letter Head Image,Pismo Head slike
Letter Head Name,Pismo Head Ime
Letter heads for print,Pismo glave za ispis
Level,Nivo
"Level 0 is for document level permissions, higher levels for field level permissions.","Razina 0 je za dokument na razini dozvole, višim razinama za terenske razine dozvola."
Lft,LFT
Link,Link
Link to other pages in the side bar and next section,Link na drugim stranicama na strani bar i sljedeću sekciju
Linked With,Povezan s
List,Popis
List items that form the package.,Popis stavki koje čine paket.
"List of Item Groups to be shown in ""All Products"" menu - in the sequence wanted and with number of indents (left spacing to show a tree effect).",Popis Artikl grupe koji će biti prikazan u &quot;Svi proizvodi&quot; izbornik - u slijedu htjela i sa brojem alineje (lijevo razmak pokazati stablo učinak).
List of companies (not customers / suppliers),Popis tvrtki (ne kupci / dobavljači)
List of holidays.,Popis blagdana.
List of patches executed,Popis zakrpe izvršenih
List of records in which this document is linked,Popis zapisa u kojoj je ovaj dokument povezanih
List this Item in multiple groups on the website.,Popis ovaj predmet u više grupa na web stranici.
Live Chat,Live Chat
Load Print View on opening of an existing form,Učitaj Print Pogled na otvaranju postojećem obliku
Loading,Utovar
Loading Report,Učitavanje izvješće
Location,Lokacija
Log of Scheduler Errors,Prijavite od Raspoređivač pogrešaka
Login After,Prijavite Nakon
Login Before,Prijavite Prije
Login Id,Prijavite Id
Login Page,Prijavite stranicu
Logout,Odjava
Long Description,Dugi opis
Long Text,Dugo Tekst
Lost Reason,Izgubili Razlog
Low,Nisko
Lower Income,Donja Prihodi
Lucida Grande,Lucidi Grande
MIS Control,MIS kontrola
MREQ,MREQ
MTN Details,MTN Detalji
Mail Footer,Mail Footer
Mail Password,Mail Lozinka
Mail Port,Mail luci
Mail Server,Mail Server
Main Reports,Glavni Izvješća
Main Section,Glavni Odjeljak
Maintain same rate throughout purchase cycle,Održavanje istu stopu tijekom kupnje ciklusa
Maintenance,Održavanje
Maintenance Date,Održavanje Datum
Maintenance Details,Održavanje Detalji
Maintenance Schedule,Održavanje Raspored
Maintenance Schedule Detail,Održavanje Raspored Detalj
Maintenance Schedule Item,Održavanje Raspored predmeta
Maintenance Status,Održavanje statusa
Maintenance Time,Održavanje Vrijeme
Maintenance Type,Održavanje Tip
Maintenance Visit,Održavanje Posjetite
Maintenance Visit Purpose,Održavanje Posjetite Namjena
Major/Optional Subjects,Glavni / Izborni predmeti
Make Bank Voucher,Napravite Bank bon
Make Credit Note,Napravite Credit Note
Make Debit Note,Napravite terećenju
Make Difference Entry,Čine razliku Entry
Make Excise Invoice,Napravite trošarinama fakture
Make Stock Entry,Napravite Stock Entry
Make a new,Napravite novi
Make sure that the transactions you want to restrict have a Link field 'territory' that maps to a 'Territory' master.,Pobrinite se da su transakcije želite ograničiti imati vezu polje &#39;teritorij&#39; koji mapira u &#39;teritorij&#39; gospodara.
Male,Muški
Manage cost of operations,Upravljanje troškove poslovanja
Manage numbering series,Upravljanje broje niz
Manage sales or purchase returns,Upravljanje prodaju ili kupnju vraća
Mandatory,Obavezan
"Mandatory if Stock Item is ""Yes""",Obvezni ako kataloški Stavka je &quot;Da&quot;
Manufacture against Sales Order,Proizvodnja protiv prodaje Reda
Manufacture/Repack,Proizvodnja / Ponovno pakiranje
Manufactured Qty,Proizvedeno Kol
Manufactured quantity will be updated in this warehouse,Proizvedeno količina će biti ažurirana u ovom skladištu
Manufacturer,Proizvođač
Manufacturer Part Number,Proizvođač Broj dijela
Manufacturing,Proizvodnja
Manufacturing Home,Proizvodnja Početna
Manufacturing Quantity,Proizvodnja Količina
Map,Karta
Margin,Marža
Marital Status,Bračni status
Markdown Reference,Smanjenje Referenca
Market Segment,Tržišni segment
Married,Oženjen
Mass Mailing,Misa mailing
Master,Majstor
Master Name,Učitelj Ime
Master Type,Majstor Tip
Masters,Majstori
Mat Detail No,Mat Detalj Ne
Match,Odgovarati
Match Id,Match ID
Match non-linked Invoices and Payments.,Klađenje na ne-povezane faktura i plaćanja.
Material Issue,Materijal Issue
Material Receipt,Materijal Potvrda
Material Request,Materijal zahtjev
Material Request Date,Materijal Zahtjev Datum
Material Request Detail No,Materijal Zahtjev Detalj Ne
Material Request For Warehouse,Materijal Zahtjev za galeriju
Material Request Item,Materijal Zahtjev artikla
Material Request Items,Materijalni Zahtjev Proizvodi
Material Request No,Materijal Zahtjev Ne
Material Request Type,Materijal Zahtjev Tip
Material Transfer,Materijal transfera
Materials,Materijali
Materials Required (Exploded),Materijali Obavezno (eksplodirala)
Materials Requirement Planning (MRP),Materijali Zahtjev za planiranje (MRP)
Max Attachments,Max Privitci
Max Days Leave Allowed,Max Dani Ostavite dopuštenih
Max Discount (%),Maks Popust (%)
Max. Limit,Maks. Ograničiti
"Meaning of Submit, Cancel, Amend","Značenje Podnijeti, Odustani, Izmijeniti"
Medium,Srednji
Merge,Spojiti
Merge Warehouses,Spoji skladišta
Merge With,Spoji S
Message,Poruka
Message Parameter,Poruka parametra
Message greater than 160 character will be splitted into multiple mesage,Poruka veća od 160 karaktera će biti splitted u više mesage
Message when Cond. False,Poruka kad Uslov. Lažan
Messages,Poruke
Method,Način
Middle Income,Srednji Prihodi
Middle Name (Optional),Krsno ime (opcionalno)
Milestone,Prekretnica
Milestone Date,Prekretnica Datum
Milestones,Dostignuća
Milestones will be added as Events in the Calendar,Dostignuća će biti dodan kao Događanja u kalendaru
Millions,Milijuni
Min Order Qty,Min Red Kol
Minimum Order Qty,Minimalna narudžba Količina
Misc,Ostalo
Misc Details,Razni podaci
Miscellaneous,Razni
Miscelleneous,Miscelleneous
Mobile No,Mobitel Nema
Mobile No.,Mobitel broj
Mode of Payment,Način plaćanja
Modified Amount,Promijenio Iznos
Modified by,Izmijenio
Module,Modul
Module Def,Modul Def
Module Name,Modul Ime
Modules,Moduli
Modules Setup,Moduli za postavljanje
Monday,Ponedjeljak
Month,Mjesec
Monthly,Mjesečno
Monthly salary statement.,Mjesečna plaća izjava.
Monthly salary template.,Mjesečna plaća predložak.
More,Više
More Details,Više pojedinosti
More Info,Više informacija
More content for the bottom of the page.,Više sadržaja za dnu stranice.
Moving Average,Moving Average
Moving Average Rate,Premještanje prosječna stopa
Mr,G.
Ms,Gospođa
Multi Ledger Report Detail,Multi knjiga Izvješće Detalj
Multiple Item Prices,Više Stavka Cijene
Mupltiple Item prices.,Mupltiple Stavka cijene.
My Company,Moja tvrtka
My Settings,Moje postavke
NL-,NL-
Name,Ime
Name Case,Ime slučaja
Name as entered in Sales Partner master,Ime kao ušao u prodajni partner gospodara
Name of organization from where lead has come,Naziv organizacije odakle je došao olovo
Name of person or organization that this address belongs to.,Ime osobe ili organizacije koje ova adresa pripada.
Name of the Budget Distribution,Ime distribucije proračuna
Name of the entity who has requested for the Purchase Requisition,Naziv subjekta koji je zatražio za kupnju rekvizicija
Naming,Imenovanje
Naming Series,Imenovanje serije
Naming Series Options,Imenovanje Serija isporuke
Negative balance is not allowed for account ,Negativna bilanca nije dopušteno za račun
Net Pay,Neto Pay
Net Pay (in words) will be visible once you save the Salary Slip.,Neto plaća (u riječima) će biti vidljiv nakon što spremite plaće Slip.
Net Total,Neto Ukupno
Net Total (Import),Neto Ukupno (Uvoz)
Net Total*,Neto Ukupno *
Net Weight,Neto težina
Net Weight UOM,Težina UOM
Net Weight of each Item,Težina svake stavke
New,Novi
New BOM,Novi BOM
New Communications,Novi komunikacije
New Delivery Notes,Novi otpremnice
New Enquiries,Novi Upiti
New Leads,Nova vodi
New Leave Application,Novi dopust Primjena
New Leaves Allocated,Novi Leaves Dodijeljeni
New Leaves Allocated (In Days),Novi Lišće alociran (u danima)
New Material Requests,Novi materijal Zahtjevi
New Name,Novo ime
New Password,Novi Lozinka
New Projects,Novi projekti
New Purchase Orders,Novi narudžbenice
New Purchase Receipts,Novi Kupnja Primici
New Quotations,Novi Citati
New Record,Novi rekord
New Sales Orders,Nove narudžbe
New Stock Entries,Novi Stock upisi
New Stock UOM,Novi kataloški UOM
New Supplier Quotations,Novi dobavljač Citati
New Support Tickets,Novi Podrška Ulaznice
New Update,Novi Update
New Workplace,Novi radnom mjestu
New value to be set,Nova vrijednost treba postaviti
Newsletter,Bilten
Newsletter Content,Newsletter Sadržaj
Newsletter Status,Newsletter Status
Next Communcation On,Sljedeća komunikacijski Na
Next Contact By,Sljedeća Kontakt Do
Next Contact Date,Sljedeća Kontakt Datum
Next Date,Sljedeća Datum
Next State,Sljedeća država
Next actions,Sljedeći akcije
Next email will be sent on:,Sljedeća e-mail će biti poslan na:
No,Ne
No Action,Nema Akcija
No Communication tagged with this ,Ne Komunikacija označio s ovim
No Copy,Ne Kopirajte
No Permission,Bez dozvole
No Permission to ,Bez dozvole na
No Permissions set for this criteria.,Nema dozvole postavljen za ove kriterije.
No User Properties found.,Nema Svojstva korisnika pronađena.
No of Requested SMS,Nema traženih SMS
No of Sent SMS,Ne poslanih SMS
No of Visits,Bez pregleda
No records tagged.,Nema zapisa tagged.
"No table is created for Single DocTypes, all values are stored in tabSingles as a tuple.","Nema stol je stvoren za jednokrevetnu DocTypes, sve vrijednosti su pohranjene u tabSingles što tuple."
None: End of Workflow,Ništa: Kraj Workflow
Not,Ne
Not Active,Ne aktivna
Not Applicable,Nije primjenjivo
Not Billed,Ne Naplaćeno
Not Delivered,Ne Isporučeno
Not Found,Not Found
Not Linked to any record.,Nije povezan s bilo rekord.
Not Permitted,Nije dopušteno
Not allowed,Nije dopušteno
Not allowed for: ,Nije dopušteno za:
Not enough permission to see links.,Nije dovoljno dozvolu za vidjeti linkove.
Not in Use,Nije u uporabi
Not interested,Ne zanima
Not linked,Ne povezan
Note: Email will not be sent to disabled users,Napomena: E-mail neće biti poslan invalide
Note: Other permission rules may also apply,Napomena: Ostala pravila dozvole također može primijeniti
Note: You Can Manage Multiple Address or Contacts via Addresses & Contacts,Napomena: možete upravljati s više adresa ili kontakti preko adrese i kontakti
Note: maximum attachment size = 1mb,Napomena: maksimalna veličina privitka = 1MB
Notes,Bilješke
Nothing to show,Ništa pokazati
Notice - Number of Days,Obavijest - Broj dana
Notification Control,Obavijest kontrola
Notification Email Address,Obavijest E-mail adresa
Notify By Email,Obavijesti e-poštom
Notify by Email on Re-order,Obavijesti putem e-pošte na Re-order
Number Format,Broj Format
O+,O +
O-,O-
OPPT,OPPT
Ocean,Okean
Old Parent,Stari Roditelj
Old Style Reports,Stari stil Izvješća
On,Na
On Net Total,Na Net Total
On Previous Row Amount,Na prethodnu Row visini
On Previous Row Total,Na prethodni redak Ukupno
"Once you have set this, the users will only be able access documents with that property.","Nakon što ste postavili ovo, korisnici će moći pristupom dokumentima s tom imovinom."
One or multiple Sales Order no which generated this Purchase Requisition,Jedan ili više prodajnog naloga ne koji generira ovu Kupnja rekvizicije
Only Allow Edit For,Samo Dopusti Uredi za
Only System Manager can create / edit reports,Samo Manager sustav može stvoriti / uređivati ​​izvješća
Only leaf nodes are allowed in transaction,Samo leaf čvorovi su dozvoljeni u transakciji
Open,Otvoreno
Open Sans,Otvoreni Sans
Open Tickets,Otvoreni Ulaznice
Opening Date,Otvaranje Datum
Opening Time,Radno vrijeme
Opening for a Job.,Otvaranje za posao.
Operating Cost,Operativni troškovi
Operation Description,Operacija Opis
Operation No,Operacija Ne
Operation Time (mins),Operacija Vrijeme (min)
Operations,Operacije
Operator,Operator
Opportunity,Prilika
Opportunity Date,Prilika Datum
Opportunity From,Prilika Od
Opportunity Item,Prilika artikla
Opportunity Items,Prilika Proizvodi
Opportunity Lost,Prilika Izgubili
Opportunity No,Prilika Ne
Opportunity Type,Prilika Tip
Options,Mogućnosti
Options Help,Opcije Pomoć
Order Confirmed,Red Potvrđeno
Order Lost,Red Izgubili
Order Type,Vrsta narudžbe
Ordered Items To Be Billed,Naručeni Stavke biti naplaćeno
Ordered Items To Be Delivered,Naručeni Proizvodi se dostavljaju
Ordered Qty,Ž Kol
Ordered Quantity,Količina Ž
Orders released for production.,Narudžbe objavljen za proizvodnju.
Organization,Organizacija
Original Message,Izvorni Poruka
Other,Drugi
Other Details,Ostali podaci
Other Income Detail,Ostali prihodi Detalj
Out going mail server and support ticket mailbox,Od odlaska mail server i podršku ulaznica spremnik
Out of AMC,Od AMC
Out of Warranty,Od jamstvo
Outgoing,Društven
Outgoing Mail Server,Odlazni Mail Server
Outgoing Mails,Odlazni mailova
Outstanding Amount,Izvanredna Iznos
Outstanding cannot be less than zero. \				 	Please match exact outstanding.,Izvanredna ne može biti manja od nule. \ Molimo odgovarati točno izvanredan.
Outstanding for Voucher ,Izvanredna za Voucheru
Over Heads,Više od šefova
Overhead,Dometnut
Overload Query,Preopterećenje upita
Overwrite,Pisati preko
Owned,U vlasništvu
P.O. Date,PO Datum
P.O. No,PO Ne
PAN Number,PAN Broj
PF No.,PF broj
PF Number,PF Broj
PI/2011/,PI/2011 /
PIN,PIN
PO,PO
PO Date,PO Datum
PO No,PO Ne
POP3 Mail Server,POP3 Mail Server
POP3 Mail Server (e.g. pop.gmail.com),POP3 Mail Server (npr. pop.gmail.com)
POP3 Mail Settings,POP3 Mail Postavke
POP3 mail server (e.g. pop.gmail.com),POP3 mail server (npr. pop.gmail.com)
POP3 server e.g. (pop.gmail.com),POP3 poslužitelj npr. (pop.gmail.com)
POS Setting,POS Podešavanje
PR Detail,PR Detalj
PRO,PRO
PS,PS
Package Item Details,Paket Stavka Detalji
Package Items,Paket Proizvodi
Package Weight Details,Paket Težina Detalji
Packed Quantity,Prepuna Količina
Packing Details,Pakiranje Detalji
Packing Detials,Pakiranje detials
Packing List,Pakiranje Popis
Packing Slip,Odreskom
Packing Slip Item,Odreskom predmet
Packing Slip Items,Odreskom artikle
Page,Stranica
Page Break,Prijelom stranice
Page HTML,Stranica HTML
Page Len,Stranica Len
Page Name,Stranica Ime
Page Role,Stranica Uloga
Page content,Sadržaj stranice
Page not found,Stranica nije pronađena
Page to show on the website,Stranica pokazati na web stranici
"Page url name (auto-generated) (add "".html"")",Stranica url ime (automatski generirani) (dodaj &quot;. Html&quot;)
Paid Amount,Plaćeni iznos
Parameter,Parametar
Parent Account,Roditelj račun
Parent BOM,Roditelj BOM
Parent Cost Center,Roditelj troška
Parent Customer Group,Roditelj Kupac Grupa
Parent Detail docname,Roditelj Detalj docname
Parent Doc Type,Roditelj Doc Tip
Parent Item,Roditelj artikla
Parent Item Group,Roditelj artikla Grupa
Parent Label,Roditelj Label
Parent Sales Person,Roditelj Prodaja Osoba
Parent Territory,Roditelj Regija
Parenttype,Parenttype
Partially Completed,Djelomično Završeni
Participants,Sudionici
Particulars,Pojedinosti
Partly Billed,Djelomično Naplaćeno
Partly Delivered,Djelomično Isporučeno
Partner,Partner
Partner Target Detail,Partner Ciljana Detalj
Partner Type,Partner Tip
Passport Number,Putovnica Broj
Password,Lozinka
Password Expires in (days),Lozinka Istječe (dana)
Patch,Zakrpa
Patch Log,Patch Prijava
Pay To / Recd From,Platiti Da / RecD Od
Payables,Obveze
Payables Group,Obveze Grupa
Payment Entries,Plaćanja upisi
Payment Entry has been modified after you pulled it. 			Please pull it again.,Plaćanje Stupanje je izmijenjen nakon što ga je izvukao. Molimo povucite ga opet.
Payment Reconciliation,Plaćanje pomirenje
Payment Terms,Uvjeti plaćanja
Payment days,Plaćanja dana
Payment to Invoice Matching Tool,Plaćanje fakture podudaranje alat
Payment to Invoice Matching Tool Detail,Plaćanje fakture podudaranje alat Detalj
Payments,Plaćanja
Payroll Setup,Plaće za postavljanje
Pending,Čekanju
Pending Review,U tijeku pregled
Percent,Postotak
Percent Complete,Postotak Cijela
Percentage Allocation,Postotak Raspodjela
Percentage variation in quantity to be allowed while receiving or delivering this item.,Postotak varijacije u količini biti dopušteno dok prima ili isporuku ovu stavku.
Percentage you are allowed to receive or deliver more against the quantity ordered. <p>For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units</p>,Postotak li je dozvoljeno primiti ili isporučiti više od količine naredio. <p> Na primjer: Ako ste naručili 100 jedinica. i tvoj ispravak je 10% onda je dozvoljeno primiti 110 jedinica </p>
Performance appraisal.,Ocjenjivanje.
Period Closing Voucher,Razdoblje Zatvaranje bon
Periodicity,Periodičnost
Perm Level,Perm Level
Permanent Accommodation Type,Stalni Tip smještaja
Permanent Address,Stalna adresa
Permission Control,Dopuštenje kontrola
Permission Engine,Dopuštenje motora
Permission Level,Dopuštenje Razina
Permission Levels,Razine dozvola
Permission Manager,Dopuštenje Manager
Permission Rules,Dopuštenje Pravila
Permissions,Dopuštenja
Permissions Settings,Dozvole Postavke
Permissions are automatically translated to Standard Reports and Searches,Dozvole automatski su prevedeni na standardnih izvješća i traži
"Permissions are set on Roles and Document Types (called DocTypes) by restricting read, edit, make new, submit, cancel, amend and report rights.","Dozvole su postavljene na ulogama i vrstama dokumenata (zove DocTypes) ograničavanjem čitati, uređivati, napraviti novi, podnijeti, otkazati, izmijeniti i prijaviti prava."
Permissions at higher levels are 'Field Level' permissions. All Fields have a 'Permission Level' set against them and the rules defined at that permissions apply to the field. This is useful incase you want to hide or make certain field read-only.,Dozvole na višim razinama &#39;terenu&#39; dozvole. Svi Polja imaju &#39;razinu dozvole&#39; set protiv njih i pravilima definiranim u to dozvole primjenjuju se na terenu. To je korisno obložiti želite sakriti ili napraviti određenu polje samo za čitanje.
"Permissions at level 0 are 'Document Level' permissions, i.e. they are primary for access to the document.","Dozvole na razini 0 su &#39;dokument razini&#39; dozvole, odnosno oni su primarni za pristup dokumentu."
Permissions translate to Users based on what Role they are assigned,Dozvole prevesti na korisnike na temelju onoga što Uloga im se dodjeljuju
Permissions will be based on this DocType,Dozvole će se na temelju ovog DOCTYPE
Person,Osoba
Person To Be Contacted,Osoba biti kontaktirani
Personal Details,Osobni podaci
Personal Email,Osobni e
Phone,Telefon
Phone No,Telefonski broj
Phone No.,Telefonski broj
Pick Columns,Pick stupce
Pin Code,Pin Code
Pincode,Pincode
Place of Issue,Mjesto izdavanja
Plan for scheduled maintenance contracts.,Plan rasporedu održavanja ugovora.
Planned Qty,Planirani Kol
Planned Quantity,Planirana količina
Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,Molimo unesite Skraćenica ili skraćeni naziv ispravno jer će biti dodan kao sufiks na sve računa šefova.
Please check,Molimo provjerite
Please click on another report from the menu.,Molimo kliknite na drugom izvješću iz izbornika.
Please enter Bill Date,Unesite Bill Datum
Please enter valid ,Unesite važeći
Please save the Newsletter before sending.,Molimo spremite Newsletter prije slanja.
Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Molimo odaberite prenositi ako želite uključiti prethodnoj fiskalnoj godini je ravnoteža ostavlja na ovoj fiskalnoj godini
Please select: ,Molimo odaberite:
Please specify Default Currency in Company Master \			and Global Defaults,Navedite Default valutu u trgovačkim društvima Master \ i Global defaultno
Please specify a valid,Navedite važeći
Plot Control,Zemljište kontrola
Point of Sale,Point of Sale
Point-of-Sale Setting,Point-of-Sale Podešavanje
Points,Bodovi
Post Graduate,Post diplomski
Post Topic,Post Tema
Posting Date,Objavljivanje Datum
Posting Time,Objavljivanje Vrijeme
Potential Sales Deal,Potencijal Prodaja Deal
Potential opportunities for selling.,Potencijalni mogućnosti za prodaju.
"Precision for Float fields (quantities, discounts, percentages etc) only for display. Floats will still be calculated up to 6 decimals.","Precizna za Float polja (količina, popusti, postoci itd.) samo za prikaz. Pluta i dalje će biti izračunata do šest decimala."
Prefix,Prefiks
Present,Sadašnje
Prevdoc DocType,Prevdoc DOCTYPE
Prevdoc Doctype,Prevdoc DOCTYPE
Preview,Prikaz
Previous Work Experience,Radnog iskustva
Price,Cijena
Price List,Cjenik
Price List Currency,Cjenik valuta
Price List Currency Conversion Rate,Cjenik valuta pretvorbe Stopa
Price List Exchange Rate,Cjenik tečajna
Price List Master,Cjenik Master
Price List Name,Cjenik Ime
Price List Rate,Cjenik Stopa
Price List Rate*,Cjenik Ocijeni *
Price List and Currency,Cjenik i valuta
Price Lists and Rates,Cjenike i cijene
Primary,Osnovni
Print Format,Ispis formata
Print Heading,Ispis Naslov
Print Hide,Ispis Sakrij
Print Width,Širina ispisa
Print Without Amount,Ispis Bez visini
Priority,Prioritet
Private,Privatan
Process,Proces
Process Payroll,Proces plaće
Produced Quantity,Proizveden Količina
Product,Proizvod
Product Categories,Kategorije proizvoda
Product Category for website,Proizvod Kategorija za web stranicu
Product Enquiry,Na upit
Product Group,Product Group
"Product Groups that are listed on the website. The first product group from this list will be listed by default on the ""Products Page""",Proizvod Grupe koje su navedene na web stranici. Prva grupa proizvoda iz ovog popisa će biti navedeni po defaultu na &quot;Proizvodi stranice&quot;
Product Settings,Postavke proizvoda
Production,Proizvodnja
Production Order,Proizvodnja Red
Production Plan Item,Proizvodnja plan artikla
Production Plan Items,Plan proizvodnje Proizvodi
Production Plan Sales Order,Proizvodnja plan prodajnog naloga
Production Plan Sales Orders,Plan proizvodnje narudžbe
Production Planning (MRP),Planiranje proizvodnje (MRP)
Production Planning Tool,Planiranje proizvodnje alat
Products Settings,Proizvodi Postavke
"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Proizvodi će biti razvrstani po težine dobi u zadane pretraživanja. Više težina-dob, veća proizvod će se pojaviti na popisu."
Profile,Profil
Profile Control,Profil kontrola
Profile Defaults,Profil Zadano
Profile Represents a User in the system.,Profil Predstavlja korisnika u sustavu.
Program / Seminar Title,Program / Seminar Naslov
Project,Projekt
Project Activity,Projekt aktivnost
Project Activity Update,Projekt Aktivnost Update
Project Control,Projekt kontrole
Project Costing,Projekt Costing
Project Details,Projekt Detalji
Project Milestone,Projekt Prekretnica
Project Milestones,Projekt Dostignuća
Project Name,Naziv projekta
Project Start Date,Projekt datum početka
Project Tasks,Projektni zadaci
Project Type,Vrsta projekta
Project Value,Projekt Vrijednost
Project activity / task.,Projekt aktivnost / zadatak.
Project master.,Projekt majstor.
Project will get saved and will be searchable with project name given,Projekt će biti spašen i da će se moći pretraživati ​​s projektom ime dano
Projected Qty,Predviđen Kol
Projects,Projekti
Projects Home,Projekti Početna
Prompt email sending to customers and suppliers,Brz e-mail slanje kupcima i dobavljačima
Prompt for Email on Submission of,Pitaj za e-poštu na podnošenje
Properties,Nekretnine
Property,Vlasništvo
Property Setter,Nekretnine seter
Property Setter overrides a standard DocType or Field property,Nekretnine seter nadjačava standardni DOCTYPE ili polja nekretnine
Property Type,Vrsta nekretnine
Provide email id registered in company,Osigurati e id registriran u tvrtki
Public,Javni
Published,Objavljen
Pull Emails from the Inbox and attach them as Communication records (for known contacts).,"Povucite e-pošte iz mape Primljeno, te ih priložiti kao Communication zapisa (za poznate kontakte)."
Pull Opportunity Detail,Povucite Opportunity Detalj
Pull Payment Entries,Povucite plaćanja tekstova
Pull Purchase Order Details,Povucite Detalji narudžbe Kupnja
Pull Quotation Items,Povucite kotaciji artikle
Pull Sales Order Items,Povucite Prodaja Predmeti Naručivanje
Pull items from Sales Order mentioned in the above table.,Povucite stavke iz prodaje Reda navedene u gornjoj tablici.
Pull sales orders (pending to deliver) based on the above criteria,Povucite prodajne naloge (na čekanju za isporuku) na temelju navedenih kriterija
Pur Order,Pur Naruči
Pur Receipt,Pur Potvrda
Purchase,Kupiti
Purchase Analytics,Kupnja Analytics
Purchase Common,Kupnja Zajednička
Purchase Date,Kupnja Datum
Purchase Details,Kupnja Detalji
Purchase Discounts,Kupnja Popusti
Purchase Document No,Kupnja Dokument br
Purchase Document Type,Kupnja Document Type
Purchase Invoice,Kupnja fakture
Purchase Invoice Advance,Kupnja fakture Predujam
Purchase Invoice Advances,Kupnja fakture Napredak
Purchase Invoice Item,Kupnja fakture predmet
Purchase Order,Narudžbenica
Purchase Order Date,Narudžbenica Datum
Purchase Order Item,Narudžbenica predmet
Purchase Order Item No,Narudžbenica Br.
Purchase Order Item Supplied,Narudžbenica artikla Isporuka
Purchase Order Items,Narudžbenica artikle
Purchase Order Items Supplied,Narudžbenica Proizvodi Isporuka
Purchase Order Items To Be Received,Narudžbenica Proizvodi treba primiti
Purchase Order Message,Narudžbenica poruku
Purchase Order Required,Narudžbenica Obvezno
Purchase Order sent by customer,Narudžbenica poslao kupca
Purchase Orders given to Suppliers.,Kupnja naloge koje je dao dobavljače.
Purchase Receipt,Račun kupnje
Purchase Receipt Item,Kupnja Potvrda predmet
Purchase Receipt Item Supplied,Kupnja Prijem artikla Isporuka
Purchase Receipt Item Supplieds,Kupnja Supplieds Stavka primitka
Purchase Receipt Items,Kupnja primitka artikle
Purchase Receipt Message,Kupnja Potvrda poruku
Purchase Receipt No,Račun kupnje Ne
Purchase Receipt Required,Kupnja Potvrda Obvezno
Purchase Return,Kupnja Povratak
Purchase Returned,Kupnja Vraćeno
Purchase Returns,Kupnja Povratak
Purchase Taxes and Charges,Kupnja Porezi i naknade
Purchase Taxes and Charges Master,Kupnja Porezi i naknade Master
Purpose,Svrha
Purpose must be one of ,Svrha mora biti jedan od
QA Inspection,QA Inspekcija
QA No,QA Ne
QAI/11-12/,QAI/11-12 /
QTN,QTN
Qty,Kol
Qty Consumed Per Unit,Kol Potrošeno po jedinici
Qty To Manufacture,Količina za proizvodnju
Qty as per Stock UOM,Količina po burzi UOM
Qualification,Kvalifikacija
Quality,Kvalitet
Quality Inspection,Provera kvaliteta
Quality Inspection Parameters,Inspekcija kvalitete Parametri
Quality Inspection Reading,Kvaliteta Inspekcija čitanje
Quality Inspection Readings,Inspekcija kvalitete Čitanja
Quantity,Količina
Quantity Requested for Purchase,Količina Traženi za kupnju
Quantity already manufactured,Količina je već proizvedeni
Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Količina predmeta dobije nakon proizvodnju / pakiranje od navedenih količina sirovina
Quantity should be equal to Manufacturing Quantity. ,Količina trebala bi biti jednaka Manufacturing količina.
Quarter,Četvrtina
Quarterly,Tromjesečni
Query,Pitanje
Query Options,Upita Mogućnosti
Query Report,Izvješće upita
Question,Pitanje
Quick Help for Setting Permissions,Brza pomoć za postavljanje dopuštenja
Quick Help for User Properties,Brza pomoć za korisnike Nekretnine
Quotation,Citat
Quotation Date,Ponuda Datum
Quotation Item,Citat artikla
Quotation Items,Kotaciji Proizvodi
Quotation Lost Reason,Citat Izgubili razlog
Quotation Message,Citat Poruka
Quotation No,Citat Ne
Quotation No.,Ponuda broj
Quotation Sent,Citat Sent
Quotation To,Ponuda za
Quotation no against which this Sales Order is made ,Ponuda ne protiv koje ovaj prodajnog naloga se vrši
Quotes to Leads or Customers.,Citati na vodi ili kupaca.
Raise Exception,Podignite Iznimka
Raise Material Request,Podignite Materijal Zahtjev
Raise Material Request when stock reaches re-order level,Podignite Materijal Zahtjev kad dionica dosegne ponovno poredak razinu
Raise Production Order,Podignite proizvodnom nalogu
Raised By,Povišena Do
Raised By (Email),Povišena Do (e)
Random,Slučajan
Range,Domet
Rate,Stopa
Rate ,Stopa
Rate Of Materials Based On,Stopa materijali na temelju
Rate at which Customer Currency is converted to customer's base currency,Stopa po kojoj Kupac valuta se pretvaraju u kupca osnovne valute
Rate at which Price list currency is converted to company's base currency,Stopa po kojoj Cjenik valute se pretvaraju u tvrtke bazne valute
Rate at which Price list currency is converted to customer's base currency,Stopa po kojoj Cjenik valute se pretvaraju u kupca osnovne valute
Rate at which customer's currency is converted to company's base currency,Stopa po kojoj se valuta klijenta se pretvaraju u tvrtke bazne valute
Rate at which supplier's currency is converted to company's base currency,Stopa po kojoj supplier valuta se pretvaraju u tvrtke bazne valute
Rate at which this tax is applied,Stopa po kojoj je taj porez se primjenjuje
Rate*,Ocijeni *
Raw Material Details,Sirovina Detalji
Raw Material Item Code,Sirovine Stavka Šifra
Raw Materials Supplied Cost,Sirovine Isporuka Troškovi
Re-Calculate Values,Ponovno izračunati vrijednosti
Re-Order Level,Re-Order Razina
Re-Order Qty,Re-Order Kol
Re-order,Ponovno bi
Re-order Level,Ponovno bi Razina
Re-order Qty,Ponovno bi Kol
Read,Čitati
Read Only,Read Only
Reading 1,Čitanje 1
Reading 10,Čitanje 10
Reading 2,Čitanje 2
Reading 3,Čitanje 3
Reading 4,Čitanje 4
Reading 5,Čitanje 5
Reading 6,Čitanje 6
Reading 7,Čitanje 7
Reading 8,Čitanje 8
Reading 9,Čitanje 9
Reason,Razlog
Reason for Leaving,Razlog za odlazak
Reason for Resignation,Razlog za ostavku
Recalculate,Preračunati
Recd Quantity,RecD Količina
Receivables,Potraživanja
Receivables Group,Potraživanja Grupa
Received Date,Datum pozicija
Received Qty,Pozicija Kol
Receiver List,Prijemnik Popis
Receiver Name,Primatelj Ime
Receiver Parameter,Prijemnik parametra
Recent,Nedavni
Recipient,Primalac
Recipients,Primatelji
Reconciliation Data,Pomirenje podataka
Reconciliation HTML,Pomirenje HTML
Reconciliation JSON,Pomirenje JSON
Recurring Id,Ponavljajući Id
Recurring Invoice,Ponavljajući Račun
Recurring Type,Ponavljajući Tip
Ref Code,Ref. Šifra
Ref Doc should be submitted?,Ref. Doc treba predati?
Ref DocType,Ref. DOCTYPE
Ref Name,Ref. Ime
Ref Rate,Ref. Stopa
Ref Rate ,Ref. Stopa
Ref Rate*,Ref. Ocijeni *
Ref SQ,Ref. SQ
Ref Type,Ref. Tip
Reference,Upućivanje
Reference Date,Referentni datum
Reference DocType Key,Referenca DOCTYPE Ključ
Reference Docname Key,Referenca Docname Ključ
Reference Name,Referenca Ime
Reference Number,Referentni broj
Reference Type,Referentna Tip
Refresh,Osvježiti
Registration Details,Registracija Brodu
Registration Info,Registracija Info
Reject HTML,Odbaciti HTML
Rejected,Odbijen
Rejected Quantity,Odbijen Količina
Rejected Serial No,Odbijen Serijski br
Rejected Warehouse,Odbijen galerija
Related Page,Vezani Stranica
Relation,Odnos
Relieving Date,Rasterećenje Datum
Remark,Primjedba
Remarks,Primjedbe
Remove,Ukloniti
Remove Bookmark,Uklonite Bookmark
Rename,Preimenovati
Rename Tool,Preimenovanje alat
Rented,Iznajmljuje
Repeat on Day of Month,Ponovite na dan u mjesecu
Replace,Zamijeniti
Replace Item / BOM in all BOMs,Zamijenite predmet / BOM u svim sastavnicama
"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM","Zamijenite određeni BOM u svim drugim sastavnicama gdje se koriste. To će zamijeniti staru vezu BOM, ažurirati troškove i regenerirati &quot;BOM eksploziju predmeta&quot; stol kao i po novom BOM"
Replied,Odgovorio
Report,Prijavi
Report Date,Prijavi Datum
Report Hide,Prijavi Sakrij
Report Name,Naziv izvješća
Report Saved,Prijavi Spremljeno
Report Script,Izvješće Skripta
Report Server Script,Prijavi Server Skripta
Report was not saved (there were errors),Izvješće nije spašen (bilo pogrešaka)
Reports,Izvješća
Reports to,Izvješća
Represents the states allowed in one document and role assigned to change the state.,Predstavlja stanja dopušteni u jednom dokumentu i uloge dodijeljene promijeniti stanje.
Reqd,Reqd
Reqd By Date,Reqd Po datumu
Request Type,Zahtjev Tip
Request for Information,Zahtjev za informacije
Request for purchase.,Zahtjev za kupnju.
Requested By,Traženi Do
Required By,Potrebna Do
Required Date,Potrebna Datum
Required Qty,Potrebna Kol
Required only for sample item.,Potrebna je samo za primjer stavke.
Required raw materials issued to the supplier for producing a sub - contracted item.,Potrebna sirovina izdane dobavljač za proizvodnju pod - ugovoreni predmet.
Reseller,Prodavač
Reserved Quantity,Rezervirano Količina
Reserved Warehouse,Rezervirano galerija
Resignation Letter Date,Ostavka Pismo Datum
Resolution,Rezolucija
Resolution Date,Rezolucija Datum
Resolution Details,Rezolucija o Brodu
Resolved By,Riješen Do
Restrict IP,Zabraniti IP
Restrict submission rights based on amount,Zabraniti podnošenje prava na temelju iznosa
Restrict user from this IP address only. Multiple IP addresses can be added by separating with commas. Also accepts partial IP addresses like (111.111.111),Zabraniti korisnika iz ove IP adrese samo. Višestruki IP adrese može biti dodan odvajajući zarezima. Također prihvaća djelomične IP adrese kao što su (111.111.111)
Restricting By User,Ograničavanje strane korisnika
Retailer,Prodavač na malo
Return Date,Povratak Datum
Return Type,Povratak Vid
Returned Qty,Vraćeno Kol
Review Date,Recenzija Datum
Rgt,Ustaša
Right,Desno
Role,Uloga
Role Name,Uloga Ime
Roles,Uloge
Roles Assigned,Uloge Dodijeljeni
Roles Assigned To User,Uloge dodijeljena Korisniku
Roles HTML,Uloge HTML
Rounded Total,Zaobljeni Ukupno
Rounded Total (Export),Zaobljeni Ukupno (izvoz)
Row,Red
Row #,Redak #
Row # ,Redak #
Rule Definition,Pravilo Definicija
Rule Name,Pravilo Ime
Rule Priority,Pravilo Prioritet
Rule Status,Pravilo Status
Rules defining transition of state in the workflow.,Pravila definiraju prijelaz stanja u tijek rada.
"Rules for how states are transitions, like next state and which role is allowed to change state etc.","Pravila za koliko su države prijelaza, kao i sljedeći države i koja uloga je dozvoljeno da promijeni stanje itd."
Run,Trčanje
SLE Exists,SLE Exists
SMS,SMS
SMS Center,SMS centar
SMS Control,SMS kontrola
SMS Gateway URL,SMS Gateway URL
SMS Log,SMS Prijava
SMS Parameter,SMS parametra
SMS Parameters,SMS Parametri
SMS Receiver,SMS-prijemnik
SMS Sender Name,SMS Sender Ime
SMS Settings,Postavke SMS
SMTP Server (e.g. smtp.gmail.com),SMTP poslužitelj (npr. smtp.gmail.com)
SO,SO
SO Date,SO Datum
SO Detail ,SO Detalj
SO Pending Qty,SO čekanju Kol
SO/10-11/,SO/10-11 /
SO1112,SO1112
SQTN,SQTN
STE,Ste
SUP,SUP
SUPP,Supp
SUPP/10-11/,SUPP/10-11 /
Salary,Plata
Salary Information,Plaća informacije
Salary Manager,Plaća Manager
Salary Mode,Plaća način
Salary Slip,Plaća proklizavanja
Salary Slip Deduction,Plaća proklizavanja Odbitak
Salary Slip Earning,Plaća proklizavanja Zarada
Salary Structure,Plaća Struktura
Salary Structure Deduction,Plaća Struktura Odbitak
Salary Structure Earning,Plaća Struktura Zarada
Salary Structure Earnings,Plaća Struktura Zarada
Salary components.,Plaća komponente.
Sales,Prodajni
Sales Analytics,Prodaja Analitika
Sales BOM,Prodaja BOM
Sales BOM Help,Prodaja BOM Pomoć
Sales BOM Item,Prodaja BOM artikla
Sales BOM Items,Prodaja BOM Proizvodi
Sales Browser,Prodaja preglednik
Sales Browser Control,Prodaja Preglednik kontrole
Sales Common,Prodaja Zajedničke
Sales Dashboard,Prodaja ploča
Sales Details,Prodaja Detalji
Sales Discounts,Prodaja Popusti
Sales Email Settings,Prodaja Postavke e-pošte
Sales Extras,Prodaja Dodaci
Sales Invoice,Prodaja fakture
Sales Invoice Advance,Prodaja Račun Predujam
Sales Invoice Item,Prodaja Račun artikla
Sales Invoice Message,Prodaja Račun Poruka
Sales Invoice No,Prodaja Račun br
Sales Order,Prodajnog naloga
Sales Order Date,Prodaja Datum narudžbe
Sales Order Item,Prodajnog naloga artikla
Sales Order Items,Prodaja Narudžbe Proizvodi
Sales Order Message,Prodajnog naloga Poruka
Sales Order No,Prodajnog naloga Ne
Sales Order Required,Prodajnog naloga Obvezno
Sales Orders Pending To Be Delivered,Prodajni nalozi na čekanju biti isporučena
Sales Orders Pending to be Delivered,Prodajni nalozi na čekanju biti isporučena
Sales Partner,Prodaja partner
Sales Partner Details,Prodaja Partner Detalji
Sales Partner Name,Prodaja Ime partnera
Sales Partner Target,Prodaja partner Target
Sales Person,Prodaja Osoba
Sales Person Name,Prodaja Osoba Ime
Sales Person Targets,Prodaje osobi Mete
Sales Rate,Prodaja Stopa
Sales Return,Prodaje Povratak
Sales Returns,Prodaja Povratak
Sales Taxes and Charges,Prodaja Porezi i naknade
Sales Taxes and Charges Master,Prodaja Porezi i naknade Master
Sales Team,Prodaja Team
Sales Team Details,Prodaja Team Detalji
Sales Team1,Prodaja Team1
Sales and Purchase,Prodaja i kupnja
Sales and Purchase Return Item,Prodaja i kupnja Povratak Stavka
Sales and Purchase Return Items,Prodaja i kupnja Povratak Stavke
Sales and Purchase Return Tool,Prodaja i kupnja Povratak Tool
Sales campaigns,Prodaja kampanje
Sales persons and targets,Prodaja osobe i ciljevi
Sales taxes template.,Prodaja porezi predložak.
Sales territories.,Prodaja teritoriji.
Salutation,Pozdrav
Sample Size,Veličina uzorka
Sanctioned Amount,Iznos kažnjeni
Sandbox,Kutija s pijeskom
Saturday,Subota
Save,Spasiti
Schedule,Raspored
Scheduled,Planiran
Scheduled Confirmation Date,Planirano Potvrda Datum
Scheduled Date,Planirano Datum
Scheduler Log,Planer Prijava
School/University,Škola / Sveučilište
Score (0-5),Ocjena (0-5)
Score Earned,Ocjena Zarađeni
Scrap %,Otpad%
Script,Skripta
Script Type,Skripta Tip
Script to attach to all web pages.,Skripta se priključiti na svim web stranicama.
Search,Traži
Search Criteria,Traži Kriteriji
Search Fields,Search Polja
Search Help,Traži Pomoć
Seasonality for setting budgets.,Sezonalnost za postavljanje proračuna.
Section Break,Odjeljak Break
Security Settings,Sigurnosne postavke
Segment Name,Segment Ime
Select,Odabrati
"Select ""Yes"" for sub - contracting items",Odaberite &quot;Da&quot; za pod - ugovorne stavke
"Select ""Yes"" if this item is to be sent to a customer or received from a supplier as a sample. Delivery notes and Purchase Receipts will update stock levels but there will be no invoice against this item.","Odaberite &quot;Da&quot; ako je ova stavka će biti poslan na kupca ili dobio od dobavljača kao uzorak. Otpremnice i kupnju primitke će ažurirati burzovne razinama, ali neće biti faktura protiv ove stavke."
"Select ""Yes"" if this item is used for some internal purpose in your company.",Odaberite &quot;Da&quot; ako ova stavka se koristi za neke unutarnje potrebe u vašoj tvrtki.
"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Odaberite &quot;Da&quot; ako ova stavka predstavlja neki posao poput treninga, projektiranje, konzalting i sl."
"Select ""Yes"" if you are maintaining stock of this item in your Inventory.",Odaberite &quot;Da&quot; ako ste održavanju zaliha ove točke u vašem inventaru.
"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.",Odaberite &quot;Da&quot; ako opskrbu sirovina na svoj dobavljača za proizvodnju ovu stavku.
Select All,Odaberite sve
Select Attachments,Odaberite privitke
Select Budget Distribution to unevenly distribute targets across months.,Odaberite Budget distribuciju neravnomjerno raspodijeliti ciljeve diljem mjeseci.
"Select Budget Distribution, if you want to track based on seasonality.","Odaberite Budget Distribution, ako želite pratiti na temelju sezonalnosti."
Select Customer,Izaberite klijenta
Select Digest Content,Odaberite Digest sadržaj
Select DocType,Odaberite DOCTYPE
Select Document Type,Odaberite vrstu dokumenta
Select Document Type or Role to start.,Odaberite vrstu dokumenta ili ulogu za početak.
Select Form,Odaberite obrazac
Select Items from Delivery Note,Odaberite artikle iz otpremnici
Select Items from Purchase Order,Odaberite artikle iz narudžbenice
Select Items from Purchase Receipt,Odaberite artikle iz kupnje primitka
Select Items from Sales Order,Odaberite artikle iz prodajnog naloga
Select Material Request,Odaberite Materijal Zahtjev
Select PR,Odaberite PR
Select Price List for the web. Leave blank to hide price.,Odaberite cjenik za webu. Ostavite prazno za skrivanje cijenu.
Select Print Format,Odaberite Print Format
Select Print Heading,Odaberite Ispis Naslov
Select Report Name,Odaberite Naziv izvješća
Select Role,Odaberite Uloga
Select Sales Orders,Odaberite narudžbe
Select Sales Orders from which you want to create Production Orders.,Odaberite narudžbe iz koje želite stvoriti radne naloge.
Select Shipping Address,Odaberite otprema adresu
Select Supplier Quotation,Odaberite Supplier ponudu
Select Terms and Conditions,Odaberite Uvjeti i pravila
Select Transaction,Odaberite transakcija
Select Type,Odaberite Vid
Select User or Property to start.,Odaberite korisnika ili imovina za početak.
Select account head of the bank where cheque was deposited.,Odaberite račun šefa banke gdje je ček bio pohranjen.
Select company name first.,Odaberite naziv tvrtke prvi.
Select dates to create a new ,Odaberite datume za stvaranje nove
Select name of Customer to whom project belongs,Odaberite ime kupca kojem projekt pripada
Select or drag across dates to create a new event.,Odaberite ili povucite preko datuma stvoriti novi događaj.
"Select shipping warehouse to show ""In Stock"" or ""Out of Stock"". To hide, leave blank","Odaberite brodska skladišta pokazati &quot;na lageru&quot; ili &quot;out of stock&quot;. Za skrivanje, ostavite prazno"
Select template from which you want to get the Goals,Odaberite predložak s kojeg želite dobiti ciljeva
Select the Employee for whom you are creating the Appraisal.,Odaberite zaposlenika za koga se stvara procjene.
Select the currency in which price list is maintained,Odaberite valutu u kojoj cjenik održava
Select the label after which you want to insert new field.,Odaberite oznaku nakon što želite umetnuti novo polje.
Select the period when the invoice will be generated automatically,Odaberite razdoblje kada faktura će biti generiran automatski
"Select the price list as entered in ""Price List"" master. This will pull the reference rates of items against this price list as specified in ""Item"" master.",Odaberite cjenik kao ušao u &quot;Cjenik&quot; gospodara. To će povući referentne stope predmeta protiv ove cjeniku kao što je navedeno u &quot;artikla&quot; gospodara.
Select the relevant company name if you have multiple companies,Odaberite odgovarajući naziv tvrtke ako imate više tvrtki
Select the relevant company name if you have multiple companies.,Odaberite odgovarajući naziv tvrtke ako imate više tvrtki.
Select who you want to send this newsletter to,Odaberite koji želite poslati ovu newsletter
Selected Attendance date will comes in the attendance template.,Odabrani posjećenost datum dolazi u posjećenosti predlošku.
"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","Odabir &quot;Da&quot; omogućit će ovu stavku da se pojavi u narudžbenice, Otkup primitka."
"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","Odabir &quot;Da&quot; omogućit će ovaj predmet shvatiti u prodajni nalog, otpremnici"
"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.",Odabir &quot;Da&quot; će vam omogućiti da stvorite Bill materijala pokazuje sirovina i operativne troškove nastale za proizvodnju ovu stavku.
"Selecting ""Yes"" will allow you to make a Production Order for this item.",Odabir &quot;Da&quot; će vam omogućiti da napravite proizvodnom nalogu za tu stavku.
"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.",Odabir &quot;Da&quot; će dati jedinstveni identitet svakog entiteta ove točke koja se može vidjeti u rednim brojem učitelja.
Selling,Prodaja
Selling Home,Prodaja Početna
Send,Poslati
Send Autoreply,Pošalji Automatski
Send Email,Pošaljite e-poštu
Send From,Pošalji Iz
Send Invite Email,Pošalji pozivnicu e
Send Me A Copy,Pošaljite mi kopiju
"Send Newsletters to your contacts, leads.","Pošaljite newslettere svojim kontaktima, vodi."
Send SMS,Pošalji SMS
Send To,Pošalji
Send To Type,Pošalji Upišite
"Send an email to users of role ""Material Manager"" and ""Purchase Manager"" when re-order level is crossed.","Pošaljite e-mail za korisnike ulogu &quot;Material Manager&quot; i &quot;Kupnja Manager&quot;, kada ponovno bi se razina prešli."
Send automatic emails to Contacts on Submitting transactions.,Pošalji automatske poruke u Kontakte o podnošenju transakcije.
"Send bulk SMS to leads, customers, contacts","Pošalji bulk SMS vodi, klijentima, kontaktima"
Send mass SMS to your contacts,Pošalji masovne SMS svojim kontaktima
Send regular summary reports via Email.,Pošalji redovite sažetak izvješća putem e-pošte.
Send to this list,Pošalji na ovom popisu
Sender,Pošiljalac
Sender Name,Pošiljatelj Ime
"Sending newsletters is not allowed for Trial users, \				to prevent abuse of this feature.","Slanje biltene nije dopušteno za suđenje korisnike, \ spriječiti zloupotrebe ove značajke."
Sent Mail,Poslana pošta
Sent On,Poslan Na
Sent Quotation,Sent Ponuda
Separate production order will be created for each finished good item.,Poseban proizvodnja kako će biti izrađen za svakog gotovog dobrom stavke.
Serial No,Serijski br
Serial No Details,Serijski nema podataka
Serial No Service Contract Expiry,Serijski Bez isteka Ugovor o pružanju usluga
Serial No Status,Serijski Bez Status
Serial No Warranty Expiry,Serijski Nema jamstva isteka
Serialized Item: ',Serijaliziranom artikla: &#39;
Series,Serija
Series Detail,Serija Detalj
Series List for this Transaction,Serija Popis za ovu transakciju
Series Options,Serija Opcije
Server,Server
Server Script,Server Skripta
Service Address,Usluga Adresa
Service Person,Usluga osoba
Session Expired. Logging you out,Sjednica je istekao. Odjavljivanje
Session Expires in (time),Sjednica Istječe u (vrijeme)
Session Expiry,Sjednica isteka
Session Expiry in Hours e.g. 06:00,Sjednica Rok u Hours npr. 06:00
Set From Image,Postavite Od Slika
Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Postavite Stavka Grupa-mudre proračune na ovom području. Također možete uključiti sezonalnost postavljanjem Distribution.
Set Login and Password if authentication is required.,"Postavite prijavu i lozinku, ako je autorizacija potrebna."
Set New Password,Set New Password
Set Value,Postavite vrijednost
"Set a new password and ""Save""",Postavite novu lozinku i &quot;Save&quot;
Set default values for entry,Postavljanje zadanih vrijednosti za ulazak
Set default values for users (also used for permissions).,Postavljanje zadanih vrijednosti za korisnike (također se koristi za dozvole).
Set multiple numbering series for transactions,Postavite više brojeva seriju transakcija
Set permissions on transactions / masters,Postavite dozvole na transakcije / Masters
Set prefix for numbering series on your transactions,Postavite prefiks za numeriranje niza na svoje transakcije
Set targets Item Group-wise for this Sales Person.,Set cilja predmet Grupa-mudar za ovaj prodavač.
Set the POP3 email settings to pull emails directly from a mailbox and create Support Tickets,Postavite POP3 postavke e povući e-mailove direktno iz spremnika i stvoriti podršku ulaznice
Set workflow rules.,Postavite tijeka pravila.
"Set your background color, font and image (tiled)","Postavite boju pozadine, font i sliku (popločan)"
"Set your outgoing mail SMTP settings here. All system generated notifications, emails will go from this mail server. If you are not sure, leave this blank to use ERPNext servers (emails will still be sent from your email id) or contact your email provider.","Postavite odlazne postavke SMTP mail ovdje. Svi sustav generira obavijesti, e-mail će otići s ovog poslužitelja e-pošte. Ako niste sigurni, ostavite prazno za korištenje ERPNext poslužitelja (e-mailove i dalje će biti poslan na vaš e-mail id) ili se obratite davatelja usluga."
Setting Account Type helps in selecting this Account in transactions.,Postavljanje Vrsta računa pomaže u odabiru ovaj račun u prometu.
Settings for About Us Page.,Postavke za O nama Page.
Settings for Contact Us Page,Postavke za Kontaktirajte nas stranicu
Settings for Contact Us Page.,Postavke za Kontaktirajte nas stranicu.
Settings for Product Catalog on the website,Postavke za Katalog proizvoda na web stranici
Settings for Product Catalog on the website.,Postavke za Katalog proizvoda na web stranici.
Settings for the About Us Page,Postavke za O nama Page
"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""",Postavke za izdvajanje posao zahtjeva iz spremnika npr. &quot;jobs@example.com&quot;
Setup,Postavljanje
Setup Control,Postavljanje kontrola
Setup Series,Postavljanje Serija
Setup of fonts and background.,Postavljanje fontova i pozadine.
"Setup of top navigation bar, footer and logo.","Postavljanje gornjoj navigacijskoj traci, podnožje i logo."
Setup outgoing SMS via your bulk SMS provider,Postava odlaznih SMS putem svog bulk SMS usluga
Setup to pull emails from support email account,Postava povući e-mailove od podrške email računa
Ship To,Brod za
Shipping Address,Dostava Adresa
Shipping Address Name,Dostava Adresa Ime
Shipping Details,Dostava Detalji
Short Description,Kratak opis
Short biography for website and other publications.,Kratka biografija za web stranice i drugih publikacija.
Shortcut,Prečac
"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Show &quot;na lageru&quot; ili &quot;Nije u skladištu&quot; temelji se na skladištu dostupna u tom skladištu.
Show / Hide Modules,Prikaži / sakrij modula
Show Details,Prikaži pojedinosti
Show Filters,Pokaži pretrage
Show Price in Website (if set),Prikaži Cijena u web (ako je postavljen)
Show Print First,Pokaži Ispis Prvo
Show a slideshow at the top of the page,Prikaži slideshow na vrhu stranice
Show in Website,Prikaži u web
Show rows with zero values,Prikaži retke s nula vrijednosti
Show this slideshow at the top of the page,Prikaži ovaj slideshow na vrhu stranice
"Show, hide modules","Show, skrivanje module"
Showing only for,Prikaz samo za
Signature,Potpis
Signature to be appended at the end of every email,Potpis se dodaje na kraju svakog e
Simplify entry forms by disabling features,Pojednostavite prijavnice onemogućavanjem značajke
Single,Singl
Single unit of an Item.,Jedna jedinica stavku.
Sky,Nebo
Slideshow,Slideshow
Slideshow Items,Slideshow Proizvodi
Slideshow Name,SLIKA Naziv
Slideshow like display for the website,Slideshow kao prikaz za web
Small Text,Mali Tekst
Snow,Snijeg
Solid background color (default light gray),Čvrsta boja pozadine (zadano svijetlo siva)
Sorry we were unable to find what you were looking for.,Nažalost nismo uspjeli pronaći ono što su tražili.
Sorry you are not permitted to view this page.,Žao nam je što nije dozvoljeno da vidite ovu stranicu.
Sorry! We can only allow upto 100 rows for Stock Reconciliation.,Žao nam je! Mi samo možemo dopustiti upto 100 redova za burze pomirenja.
Sort By,Sortiraj po
Sort Order,Sortiranja
Source,Izvor
Source Warehouse,Izvor galerija
Source and Target Warehouse cannot be same,Izvor i Target galerije ne mogu biti isti
Source of th,Izvor th
"Source of the lead. If via a campaign, select ""Campaign""","Izvor olova. Ako putem kampanje, odaberite &quot;kampanja&quot;"
Special Page Settings,Posebni stranica Postavke
Specification Details,Specifikacija Detalji
Split Delivery Note into packages.,Split otpremnici u paketima.
Standard,Standard
Standard Rate,Standardna stopa
"Standard Terms and Conditions that can be added to Sales and Purchases.Examples:1. Validity of the offer.1. Payment Terms (In Advance, On Credit, part advance etc).1. What is extra (or payable by the Customer).1. Safety / usage warning.1. Warranty if any.1. Returns Policy.1. Terms of shipping, if applicable.1. Ways of addressing disputes, indemnity, liability, etc.1. Address and Contact of your Company.","Standardni uvjeti da se može dodati prodaje i Purchases.Examples: 1. Valjanost offer.1. Uvjeti plaćanja (unaprijed, na kredit, dio unaprijed i sl) 0,1. Što je ekstra (ili plaća kupac) 0,1. Sigurnost / korištenje warning.1. Jamstvo ako any.1. Vraća Policy.1. Uvjeti shipping, ako applicable.1. Načinima rješavanja sporova, odšteta, odgovornost, etc.1. Adresu i kontakt vaše tvrtke."
"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.#### NoteThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.#### Description of Columns1. Calculation Type:     - This can be on **Net Total** (that is the sum of basic amount).    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.    - **Actual** (as mentioned).2. Account Head: The Account ledger under which this tax will be booked3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.4. Description: Description of the tax (that will be printed in invoices / quotes).5. Rate: Tax rate.6. Amount: Tax amount.7. Total: Cumulative total to this point.8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.10. Add or Deduct: Whether you want to add or deduct the tax.","Standardni porez predložak koji se mogu primijeniti na sve transakcije kupnje. Ovaj predložak može sadržavati popis poreznih glavama i također ostalim troškovima glave poput &quot;brodova&quot;, &quot;osiguranje&quot;, &quot;Rukovanje&quot; itd. # # # # NoteThe porezna stopa možete definirati ovdje će biti standardna stopa poreza za sve stavke ** ** . Ako postoje ** Proizvodi ** koji imaju različite cijene, one moraju biti dodan u ** artikla porezu ** tablice u točki ** ** majstor. # # # # Opis Columns1. Obračun Tip: - To može biti na ** Neto Ukupno ** (koja je zbroj osnovnog iznosa). - ** Na prethodni redak Ukupni / Iznos ** (za kumulativne poreza ili pristojbi). Ako odaberete ovu opciju, porez će se primijeniti kao postotak prethodnog reda (u poreznom tablici) iznos ili ukupno. - ** Stvarni ** (kao što je spomenuto) 0,2. Račun Voditelj: Račun knjiga pod kojima taj porez će biti booked3. Trošak Centar: Ako pristojba / zadužen je prihod (kao shipping) ili rashod to treba biti rezervirano protiv troškova Center.4. Opis: Opis poreza (koji će se tiskati u fakturama / citati) 0,5. Ocijeni: Porezna rate.6. Iznos: Porezna amount.7. Ukupno: Kumulativna ukupno ove point.8. Unesite Row: Ako se temelji na &quot;Prethodni Row Totala&quot; možete odabrati broj retka koji će se uzeti kao osnova za ovaj izračun (default je prethodni redak) 0,9. Razmislite poreza ili pristojbi za: U ovom dijelu možete odrediti ako porez / naknada je samo za vrednovanje (nije dio od ukupnog broja) ili samo za ukupno (ne dodati vrijednost stavke) ili za both.10. Dodavanje ili oduzimamo: želite li dodati ili odbiti porez."
"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.#### NoteThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.#### Description of Columns1. Calculation Type:     - This can be on **Net Total** (that is the sum of basic amount).    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.    - **Actual** (as mentioned).2. Account Head: The Account ledger under which this tax will be booked3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.4. Description: Description of the tax (that will be printed in invoices / quotes).5. Rate: Tax rate.6. Amount: Tax amount.7. Total: Cumulative total to this point.8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standardni porez predložak koji se mogu primijeniti na svim prodajnim transakcijama. Ovaj predložak može sadržavati popis poreznih glavama i također ostali rashodi / prihodi glave poput &quot;brodova&quot;, &quot;osiguranje&quot;, &quot;Rukovanje&quot; itd. # # # # NoteThe porezna stopa možete definirati ovdje će biti standardna stopa poreza za sve stavke ** **. Ako postoje ** Proizvodi ** koji imaju različite cijene, one moraju biti dodan u ** artikla porezu ** tablice u točki ** ** majstor. # # # # Opis Columns1. Obračun Tip: - To može biti na ** Neto Ukupno ** (koja je zbroj osnovnog iznosa). - ** Na prethodni redak Ukupni / Iznos ** (za kumulativne poreza ili pristojbi). Ako odaberete ovu opciju, porez će se primijeniti kao postotak prethodnog reda (u poreznom tablici) iznos ili ukupno. - ** Stvarni ** (kao što je spomenuto) 0,2. Račun Voditelj: Račun knjiga pod kojima taj porez će biti booked3. Trošak Centar: Ako pristojba / zadužen je prihod (kao shipping) ili rashod to treba biti rezervirano protiv troškova Center.4. Opis: Opis poreza (koji će se tiskati u fakturama / citati) 0,5. Ocijeni: Porezna rate.6. Iznos: Porezna amount.7. Ukupno: Kumulativna ukupno ove point.8. Unesite Row: Ako se temelji na &quot;Prethodni Row Totala&quot; možete odabrati broj retka koji će se uzeti kao osnova za ovaj izračun (default je prethodni redak) 0,9. Je li ovo pristojba uključena u osnovne stope:? Ako to provjerili, to znači da taj porez neće biti prikazan ispod točke tablici, ali će biti uključeni u osnovne stope u glavnom točkom tablici. To je korisno gdje želite dati flat cijenu (uključujući sve poreze) cijenu za kupce."
Start Date,Datum početka
Start Report For,Početak izvješće za
Start date of current invoice's period,Početak datum tekućeg razdoblja dostavnice
Starts on,Počinje na
Startup,Stavljanje u pogon
State,Država
State Name,Država Ime
States,Države
Static Parameters,Statički parametri
Status,Status
Status must be one of ,Status mora biti jedan od
Statutory info and other general information about your Supplier,Zakonska info i druge opće informacije o vašem Dobavljaču
Stock,Zaliha
Stock Ageing,Kataloški Starenje
Stock Analytics,Stock Analytics
Stock Balance,Kataloški bilanca
Stock Entry,Kataloški Stupanje
Stock Entry Detail,Kataloški Stupanje Detalj
Stock Frozen Upto,Kataloški Frozen Upto
Stock Home,Kataloški Početna
Stock Ledger,Stock Ledger
Stock Ledger Entry,Stock Ledger Stupanje
Stock Level,Kataloški Razina
Stock Qty,Kataloški Kol
Stock Queue (FIFO),Kataloški red (FIFO)
Stock Reconciliation,Kataloški pomirenje
Stock Reconciliation file not uploaded,Kataloški Pomirenje datoteka nije ustupio
Stock UOM,Kataloški UOM
Stock UOM Replace Utility,Kataloški UOM Zamjena Utility
Stock Uom,Kataloški Uom
Stock Value,Stock vrijednost
"Stock level frozen up to this date, nobody can do / modify entry except authorized person","Stock razina zamrznuta do tog datuma, nitko ne može učiniti / mijenjati ulazak osim ovlaštene osobe"
Stop,Stop
Stop users from making Leave Applications on following days.,Prestani korisnike od izrade ostaviti aplikacija na sljedećim danima.
Stopped,Zaustavljen
Structure cost centers for budgeting.,Struktura troška za budžetiranja.
Structure of books of accounts.,Struktura knjige računa.
Style,Stil
Style Settings,Stil Postavke
"Style represents the button color: Success - Green, Danger - Red, Inverse - Black, Primary - Dark Blue, Info - Light Blue, Warning - Orange","Stil predstavlja boju gumba: Uspjeh - zelena, opasnosti - Crvena, Inverzni - crna, Primarni - tamnoplava, info - svjetlo plava, upozorenje - Orange"
"Sub-currency. For e.g. ""Cent""",Sub-valuta. Za npr. &quot;centi&quot;
Sub-domain provided by erpnext.com,Pod-domene pruža erpnext.com
Subcontract,Podugovor
Subdomain,Poddomena
Subject,Predmet
Submit,Podnijeti
Submit Salary Slip,Slanje plaće Slip
Submit all salary slips for the above selected criteria,Slanje sve plaće gaćice za gore odabranih kriterija
Submitted,Prijavljen
Success,Uspjeh
Suggestion,Prijedlog
Suggestions,Prijedlozi
Sunday,Nedjelja
Sunny,Sunčani
Supplier,Dobavljač
Supplier (vendor) name as entered in supplier master,Dobavljač (prodavatelja) ime kao ušao u dobavljača gospodara
Supplier Address,Dobavljač Adresa
Supplier Details,Dobavljač Detalji
Supplier Intro,Dobavljač Uvod
Supplier Master created by ,Dobavljač Master stvorio
Supplier Name,Dobavljač Ime
Supplier Part Number,Dobavljač Broj dijela
Supplier Quotation,Dobavljač Ponuda
Supplier Quotation Item,Dobavljač ponudu artikla
Supplier Reference,Dobavljač Referenca
Supplier Type,Dobavljač Tip
Supplier Warehouse,Dobavljač galerija
Supplier classification.,Dobavljač klasifikacija.
Supplier database.,Dobavljač baza podataka.
Supplier of Goods or Services.,Dobavljač robe ili usluga.
Supplier warehouse where you have issued raw materials for sub - contracting,Dobavljač skladište gdje ste izdali sirovine za pod - ugovaranje
Supplier's currency,Dobavljačeva valuta
Support,Podržati
Support Analytics,Podrška Analytics
Support Email,Podrška e
Support Email Id,Podrška Email ID
Support Home,Podrška Početna
Support Password,Podrška Lozinka
Support Ticket,Podrška karata
Support Ticket Mail Settings,Podrška Settings Mail ulaznica
Support queries from customers via email or website.,Podrška upita od klijenata putem e-maila ili web stranicu.
Symbol,Simbol
Sync Inbox,Sync inbox
Sync Support Mails,Sinkronizacija Podrška mailova
System,Sistem
System Console,Sustav konzole
System Defaults,Sustav Zadano
System User,Sustav Upute
"System User (login) ID. If set, it will become default for all HR forms.","Sustav Korisničko (login) ID. Ako je postavljen, to će postati zadana za sve HR oblicima."
System generated mails will be sent from this email id.,Sustav generira mailova će biti poslan na ovaj email id.
Table,Stol
Table Field,Tablica Polje
Table Mapper Detail,Tablica Mapper Detalj
Table Mapper Details,Tablica Mapper Detalji
Table for Item that will be shown in Web Site,Tablica za predmet koji će biti prikazan u web stranice
Tag,Privjesak
Tag Name,Oznaka Ime
Tags,Oznake
Tahoma,Tahoma
Target,Meta
Target  Amount,Ciljana Iznos
Target Detail,Ciljana Detalj
Target Details,Ciljane Detalji
Target Details1,Ciljana Details1
Target Distribution,Ciljana Distribucija
Target Qty,Ciljana Kol
Target Warehouse,Ciljana galerija
Task,Zadatak
Task Details,Zadatak Detalji
Task Id,Zadatak Id
Task Name,Zadatak Ime
Tasks,Zadaci
Tasks belonging to this Project.,Zadaci koje pripadaju ovom projektu.
Tax,Porez
Tax Amount,Iznos poreza
Tax Calculation,Obračun poreza
Tax Rate,Porezna stopa
Tax Template for Purchase,Porezna Predložak za kupnju
Tax Template for Sales,Porezna Predložak za prodaju
Tax and other salary deductions.,Porez i drugih isplata plaća.
Tax detail table fetched from item master as a string and stored in this field.Used for Taxes and Charges,Porezna detalj stol preuzeta iz točke majstora kao string i pohranjeni u to field.Used za poreze i pristojbe
Taxable,Oporeziva
Taxes,Porezi
Taxes and Charges,Porezi i naknade
Taxes and Charges Added,Porezi i naknade Dodano
Taxes and Charges Added (Import),Porezi i naknade Dodano (Uvoz)
Taxes and Charges Calculation,Porezi i naknade Proračun
Taxes and Charges Deducted,Porezi i naknade oduzeti
Taxes and Charges Deducted (Import),Porezi i naknade Umanjenja (Uvoz)
Taxes and Charges Total,Porezi i naknade Ukupno
Taxes and Charges Total*,Porezi i naknade Ukupno *
Taxes and Charges1,Porezi i Charges1
Team Members,Članovi tima
Team Members Heading,Članovi tima Naslov
Template for employee performance appraisals.,Predložak za zaposlenika ocjeni rada.
Template of terms or contract.,Predložak termina ili ugovor.
Term Details,Oročeni Detalji
Terms and Conditions,Odredbe i uvjeti
Terms and Conditions Content,Uvjeti sadržaj
Terms and Conditions Details,Uvjeti Detalji
Terms and Conditions HTML,Uvjeti HTML
Terms and Conditions Template,Uvjeti predloška
Terms and Conditions1,Odredbe i Conditions1
Territory,Teritorija
Territory Manager,Teritorij Manager
Territory Name,Regija Ime
Territory Targets,Teritorij Mete
TerritoryHelp,TerritoryHelp
Test,Test
Test Data,Test podataka
Test Date,Test Datum
Test Email Id,Test E-mail ID
Test Link,Test linkova
Test Runner,Test Runner
Test Select,Test Odaberite
Test Text,Test Tekst
Test the Newsletter,Test Newsletter
Text,Tekst
Text Align,Tekst Poravnajte
Text Editor,Tekst Editor
"The ""Web Page"" that is the website home page",&quot;Web stranica&quot; da je stranica web kući
The BOM which will be replaced,BOM koji će biti zamijenjen
"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""",Stavka koja predstavlja paket. Ova stavka mora imati &quot;Je kataloški Stavka&quot; kao &quot;Ne&quot; i &quot;Je li prodaja artikla&quot; kao &quot;Da&quot;
The account to which you will pay (have paid) the money to.,Računa na koji ćete uplatiti (platio) novac.
The date at which current entry is corrected in the system.,Datum na koji tekući zapis ispravljen u sustavu.
The date at which current entry is made in system.,Datum na koji tekući zapis se sastoji u sustavu.
The date at which current entry will get or has actually executed.,Datum na koji tekući zapis će dobiti ili zapravo je pogubljen.
The date on which next invoice will be generated. It is generated on submit.,Datum na koji sljedeći račun će biti generiran. To je generiran na podnijeti.
The date on which recurring invoice will be stop,Datum na koji se ponavlja faktura će se zaustaviti
"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ","Dan u mjesecu na koji se automatski računa će biti generiran npr. 05, 28 itd."
The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruto težina paketa. Obično neto težina + ambalaža težina. (Za tisak)
The name of your company / website as you want to appear on browser title bar. All pages will have this as the prefix to the title.,Naziv tvrtke / web stranice kao što želite da se pojavi na naslovnoj traci preglednika. Sve stranice će imati to kao prefiks na naslov.
The net weight of this package. (calculated automatically as sum of net weight of items),Neto težina tog paketa. (Automatski izračunava kao zbroj neto težini predmeta)
The new BOM after replacement,Novi BOM nakon zamjene
The rate at which Bill Currency is converted into company's base currency,Stopa po kojoj Bill valuta pretvara u tvrtke bazne valute
"The system provides pre-defined roles, but you can <a href='#List/Role'>add new roles</a> to set finer permissions","Sustav pruža unaprijed definiranim ulogama, ali možete <a href='#List/Role'>dodati nove uloge</a> postaviti finije dozvole"
The unique id for tracking all recurring invoices. It is generated on submit.,Jedinstveni ID za praćenje svih ponavljajući fakture. To je generiran na podnijeti.
Theme,Tema
Then By (optional),Zatim Do (opcionalno)
These properties are Link Type fields from all Documents.,Ta svojstva su Link Tip polja iz svih dokumenata.
"These properties can also be used to 'assign' a particular document, whose property matches with the User's property to a User. These can be set using the <a href='#permission-manager'>Permission Manager</a>","Ta svojstva se također može koristiti za &#39;dodijeliti&#39; određeni dokument, čija imovina utakmice s Korisničkom imovine korisniku. To se može podesiti pomoću <a href='#permission-manager'>dozvolu Manager</a>"
These properties will appear as values in forms that contain them.,Ta svojstva će se pojaviti kao vrijednosti u oblicima koji ih sadrže.
These values will be automatically updated in transactions and also will be useful to restrict permissions for this user on transactions containing these values.,"Ove vrijednosti će se automatski ažuriraju u prometu, te će također biti korisno ograničiti dozvole za ovog korisnika o transakcijama koje sadrže te vrijednosti."
"This Item Group represents ""products.html""",Ova točka Grupa predstavlja &quot;products.html&quot;
This Price List will be selected as default for all Customers under this Group.,Ovaj Cjenik će biti odabran kao uobičajeni za sve kupce iz ove skupine.
This currency will get fetched in Purchase transactions of this supplier,Ova valuta će se dohvatio u Kupiti transakcija ovog dobavljača
This currency will get fetched in Sales transactions of this customer,Ova valuta će se dohvatio u prodajnim transakcijama ovog kupca
"This feature is for merging duplicate warehouses. It will replace all the links of this warehouse by ""Merge With"" warehouse. After merging you can delete this warehouse, as stock level for this warehouse will be zero.","Ova je značajka za spajanje duple skladišta. To će zamijeniti sve linkove u ovom skladištu strane &quot;spojiti s&quot; skladišta. Nakon spajanja možete izbrisati ovaj skladište, kao dioničko razina za ovaj skladište će biti nula."
This field will appear only if the fieldname defined here has value OR the rules are true (examples): <br>myfieldeval:doc.myfield=='My Value'<br>eval:doc.age>18,"Ovo polje će se pojaviti samo ako podataka, Naziv Polja definirana ovdje ima vrijednost ILI pravila su istina (primjeri): <br> myfieldeval: doc.myfield == &#39;Moj Vrijednost&#39; <br> eval: doc.age&gt; 18"
This goes above the slideshow.,To ide iznad slideshow.
This is PERMANENT action and you cannot undo. Continue?,"To je stalna akcija, a ne možete poništiti. Nastaviti?"
This is permanent action and you cannot undo. Continue?,"To je stalna akcija, a ne možete poništiti. Nastaviti?"
This is the number of the last created transaction with this prefix,To je broj zadnjeg stvorio transakcije s ovim prefiksom
This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Ovaj alat pomaže vam da ažurirate ili popraviti količinu i vrednovanja zaliha u sustavu. To se obično koristi za sinkronizaciju sustava vrijednosti i što zapravo postoji u svojim skladištima.
This will be used for setting rule in HR module,To će se koristiti za postavljanje pravilu u HR modula
Thread HTML,Temu HTML
Thumbnail Image,Thumbnail slika
Thursday,Četvrtak
Time,Vrijeme
Time Zone,Time Zone
Time Zones,Vremenske zone
Time and Budget,Vrijeme i proračun
Time at which items were delivered from warehouse,Vrijeme na stavke koje su isporučena iz skladišta
Time at which materials were received,Vrijeme u kojem su materijali primili
Timesheet,Kontrolna kartica
Timesheet By,Timesheet Do
Timesheet Date,Timesheet Datum
Timesheet Detail,Timesheet Detalj
Timesheet Details,Timesheet Detalji
Timesheet for tasks.,Timesheet za zadatke.
Title,Naslov
Title / headline of your page,Naslov / naslov vaše stranice
Title Case,Naslov slučaja
Title Prefix,Naslov Prefiks
To,Na
To Date,Za datum
To Discuss,Za Raspravljajte
To Do,Da li
To Do List,Da li popis
To DocType,Za DOCTYPE
To Field,Za Field
To PR Date,Za PR Datum
To Package No.,Za Paket br
To Reply,Za Odgovor
To Table,Da tablici
To Warehouse,Za galeriju
"To add a tag, open the document and click on ""Add Tag"" on the sidebar","Da biste dodali oznaku, otvorite dokument i kliknite na &quot;Dodaj oznaku&quot; na sidebar"
"To assign this issue, use the ""Assign"" button in the sidebar.","Za dodjelu taj problem, koristite &quot;dodijeliti&quot; gumb u sidebar."
"To automatically create Support Tickets from your incoming mail, set your POP3 settings here. You must ideally create a separate email id for the erp system so that all emails will be synced into the system from that mail id. If you are not sure, please contact your EMail Provider.","Da biste automatski stvorili podršku ulaznice iz vašeg dolaznog maila, postaviti POP3 postavke ovdje. Vi idealno mora stvoriti zasebnu e-mail ID za ERP sustava, tako da sve e-mailove će biti sinkronizirane u sustav iz tog mail id. Ako niste sigurni, obratite se davatelju usluge e."
"To create Quotation against Opportunity, Select Opportunity No. and click on 'Pull Opportunity Details' ","Za izradu ponudu protiv Opportunity, odaberite Opportunity broj i kliknite na &quot;povući Opportunity podaci &#39;"
"To create an Account Head under a different company, select the company and save customer.","Za stvaranje računa glavu pod drugom tvrtkom, odaberite tvrtku i spasiti kupca."
To enable <b>Point of Sale</b> features,Da biste omogućili <b>Point of Sale</b> značajke
"To fetch items again, click on 'Get Items' button \						or update the Quantity manually.","Za preuzimanje stavke opet, kliknite na &quot;Get stavke&quot; gumb \ ili ažurirati Količina ručno."
"To further restrict permissions based on certain values in a document, use the 'Condition' settings.","Kako bi se dodatno ograničiti dozvole na temelju određenih vrijednosti u dokumentu, koristite &#39;stanje&#39; postavke."
To get Item Group in details table,Da biste dobili predmeta Group u tablici pojedinosti
"To import attendance data, click on ""Add"" button, select the saved CSV file and click on ""Upload"".Select the date format as attendance date format in CSV file.Click on ""Import"".","Za uvoz pohađanje podatke, kliknite na &quot;Dodaj&quot; gumb, odaberite spremljenu CSV datoteku i kliknite na &quot;Prenesi&quot;. Odaberite format datuma kao posjećenosti datumu formatu CSV file.Click na &quot;uvoz&quot;."
To manage multiple series please go to Setup > Manage Series,Za upravljati s više niz molimo idite na Postavke&gt; Upravljanje serije
To restrict a User of a particular Role to documents that are explicitly assigned to them,Da biste ograničili korisnik određenu ulogu na dokumente koji su izričito dodijeljene im
To restrict a User of a particular Role to documents that are only self-created.,Da biste ograničili korisnik određenu ulogu dokumentima koji su samo self-kreirana.
"To set user roles, just go to <a href='#List/Profile'>Setup > Users</a> and click on the user to assign roles.","Da biste postavili korisničke uloge, samo idite na <a href='#List/Profile'>Postavke&gt; Korisnici</a> i kliknite na korisnika dodijeliti uloge."
To track any installation or commissioning related work after sales,Za praćenje bilo koju instalaciju ili puštanje vezane raditi nakon prodaje
"To track brand name in the following documents<br>Delivery Note, Enuiry, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Sales BOM, Sales Order, Serial No","Za praćenje branda u sljedećim dokumentima <br> Otpremnica, Enuiry, Materijal zahtjev, točka, Narudžbenica, Otkup bon, Kupac Potvrda, citat, prodaja Račun, prodaja BOM, prodajnog naloga, Serijski br"
To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Za praćenje stavke u prodaji i kupnji dokumenata na temelju njihovih serijskih br. To je također može koristiti za praćenje jamstvene podatke o proizvodu.
To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,Za praćenje stavke u prodaji i kupnji dokumenata s batch br <br> <b>Prošle Industrija: Kemikalije itd</b>
To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Za praćenje stavki pomoću barkod. Vi ćete biti u mogućnosti da unesete stavke u otpremnici i prodaje Računa skeniranjem barkod stavke.
"To update your HTML from attachment, click here","Da biste ažurirali svoj HTML iz vezanosti, kliknite ovdje"
ToDo,ToDo
Tools,Alat
Top Bar,Najbolje Bar
Top Bar Background,Najbolje Bar Pozadina
Top Bar Item,Najbolje Bar artikla
Top Bar Items,Top Bar Proizvodi
Total,Ukupan
Total (sum of) points distribution for all goals should be 100.,Ukupno (zbroj) boda distribucije svih ciljeva trebao biti 100.
Total +Tax,Ukupno + Porezna
Total Advance,Ukupno Predujam
Total Amount,Ukupan iznos
Total Amount To Pay,Ukupan iznos platiti
Total Amount in Words,Ukupan iznos u riječi
Total Claimed Amount,Ukupno Zatražio Iznos
Total Commission,Ukupno komisija
Total Cost,Ukupan trošak
Total Credit,Ukupna kreditna
Total Debit,Ukupno zaduženje
Total Deduction,Ukupno Odbitak
Total Earning,Ukupna zarada
Total Experience,Ukupno Iskustvo
Total Hours (Actual),Ukupno vrijeme (Stvarni)
Total Hours (Expected),Ukupno vrijeme (Očekivani)
Total Invoiced Amount,Ukupno Iznos dostavnice
Total Leave Days,Ukupno Ostavite Dani
Total Leaves Allocated,Ukupno Lišće Dodijeljeni
Total Operating Cost,Ukupni trošak
Total Points,Ukupno bodova
Total Raw Material Cost,Ukupno troškova sirovine
Total SMS Sent,Ukupno SMS Sent
Total Sanctioned Amount,Ukupno kažnjeni Iznos
Total Score (Out of 5),Ukupna ocjena (od 5)
Total Tax,Ukupno poreza
Total Tax Amount,Ukupno Iznos poreza
Total Tax*,Ukupno poreza *
Total Taxes and Charges,Ukupno Porezi i naknade
Total days in month,Ukupno dana u mjesecu
Total in words,Ukupno je u riječima
Totals,Ukupan rezultat
Track Quotations received from Suppliers.,Pratite primljenih ponuda iz dobavljače.
Track separate Income and Expense for product verticals or divisions.,Pratite posebnu prihodi i rashodi za proizvode vertikalama ili podjele.
Track this Delivery Note against any Project,Prati ovu napomenu isporuke protiv bilo Projekta
Track this Sales Invoice against any Project,Prati ovu Sales fakture protiv bilo Projekta
Track this Sales Order against any Project,Prati ovu prodajni nalog protiv bilo Projekta
Transaction,Transakcija
Transaction Date,Transakcija Datum
Transfer,Prijenos
Transfer stock from one warehouse to another.,Prijenos dionica iz jednog skladišta na drugo.
Transition Rules,Prijelazna pravila
Transporter Info,Transporter Info
Transporter Name,Transporter Ime
Transporter lorry number,Transporter kamion broj
Trash,Otpad
Trash Control,Smeće kontrola
Trash Reason,Otpad Razlog
Tree of item classification,Stablo točke klasifikaciji
Trend Analyzer,Trend Analyzer
Trend Analyzer Control,Trend Analyzer kontrola
Trial Balance,Pretresno bilanca
Tropic,Povratnik
Tuesday,Utorak
Type,Vrsta
Type of employment master.,Vrsta zaposlenja gospodara.
"Type of leaves like casual, sick etc.","Tip lišća poput casual, bolovanja i sl."
Types of Expense Claim.,Vrste Rashodi zahtjevu.
Types of activities for Time Sheets,Vrste aktivnosti za vrijeme listova
Types of warehouse,Vrste skladišta
UOM,UOM
UOM Conversion Detail,UOM pretvorbe Detalj
UOM Conversion Details,UOM pretvorbe Detalji
UOM Conversion Factor,UOM konverzijski faktor
UOM Details,UOM Detalji
UOM Name,UOM Ime
UOM Replace Utility,UOM Zamjena Utility
UPPER CASE,Velika slova
URL,URL
Unable to complete request: ,Nije moguće ispuniti zahtjev:
Under AMC,Pod AMC
Under Graduate,Pod diplomski
Under Section,Pod Odjela
Under Warranty,Pod jamstvo
Unit of Measure,Jedinica mjere
"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Jedinica za mjerenje ove točke (npr. kg, Jedinica Ne, Par)."
Units/Hour,Jedinice / sat
Units/Shifts,Jedinice / smjene
Unmatched Amount,Nenadmašan Iznos
Unread Messages,Nepročitane poruke
Unscheduled,Neplanski
Unsubscribe,Unsubscribe
Unsubscribed,Pretplatu
Update,Ažurirati
Update Clearance Date,Ažurirajte provjeri datum
Update Delivery Date,Ažurirajte datum isporuke
Update Field,Update Field
Update PR,Update PR
Update Sales Order,Ažurirajte prodajnog naloga
Update Series,Update serija
Update Series Number,Update serije Broj
Update Stock,Ažurirajte Stock
Update Value,Ažurirajte vrijednost
"Update allocated amount in the above table and then click ""Allocate"" button","Ažurirajte dodijeljeni iznos u gornjoj tablici, a zatim kliknite na &quot;alocirati&quot; gumb"
Update bank payment dates with journals.,Update banka datum plaćanja s časopisima.
Updates,Ažuriranja
Updates HTML,Ažuriranja HTML
Upload Attachment,Prenesi Prilog
Upload Attendance Data,Prenesi Gledatelji podataka
Upload HTML,Prenesi HTML
Upload a file,Prenesi datoteku
Upload attendance,Prenesi prisustvo
Upload attendance from a .csv file,Prenesi dolazak iz. Csv datoteku
Upload stock balance via csv.,Prenesi dionica ravnotežu putem CSV.
Upper Income,Gornja Prihodi
Urgent,Hitan
Use Multi-Level BOM,Koristite multi-level BOM
Use SSL,Koristite SSL
User,Korisnik
User Cannot Create,Korisnik ne može stvoriti
User Cannot Search,Korisnik ne može tražiti
User ID,Korisnički ID
User Image,Upute slike
User Name,Korisničko ime
User Properties,Svojstva korisnika
User Remark,Upute Zabilješka
User Remark will be added to Auto Remark,Upute Napomena će biti dodan Auto Napomena
User Tags,Upute Tags
User Type,Vrsta korisnika
User must always select,Korisničko uvijek mora odabrati
User not allowed entry in the Warehouse,Korisnik ne smije ulaz u galeriju
UserRole,UserRole
Username,Korisničko ime
Users,Korisnici
Users Voted,Korisnici Glasao
Users with this role are allowed to do / modify accounting entry before frozen date,Korisnici s tom ulogom smiju raditi / mijenjati računovodstvenu ulazak prije zamrznute dana
Users with this role are allowed to do / modify stock entry before frozen date,Korisnici s tom ulogom smiju raditi / mijenjati stock ulazak prije zamrznute dana
Utilities,Komunalne usluge
Utility,Korisnost
Valid Upto,Vrijedi Upto
Validation Logic,Provjera Logika
Valuation,Procjena
Valuation Control,Vrednovanje kontrola
Valuation Method,Vrednovanje metoda
Valuation Rate,Vrednovanje Stopa
Valuation and Total,Vrednovanje i Total
Value,Vrijednost
Verdana,Verdana
Verified By,Ovjeren od strane
Visit,Posjetiti
Visit report for maintenance call.,Posjetite izvješće za održavanje razgovora.
Voucher Detail No,Bon Detalj Ne
Voucher ID,Bon ID
Voucher Import Tool,Bon Uvoz alat
Voucher No,Bon Ne
Voucher Type,Bon Tip
WIP Monitor,WIP Monitor
Waiting for Customer,Čeka kupca
Walk In,Šetnja u
Warehouse,Skladište
Warehouse Contact Info,Skladište Kontakt Info
Warehouse Detail,Skladište Detalj
Warehouse Name,Skladište Ime
Warehouse Type,Skladište Tip
Warehouse User,Skladište Upute
Warehouse Users,Skladište Korisnika
Warehouse where you are maintaining stock of rejected items,Skladište gdje ste održavanju zaliha odbijenih stavki
Warehouse-wise Item Reorder,Warehouse-mudar Stavka redoslijeda
Warn,Upozoriti
Warning,Upozorenje
Warranty / AMC Details,Jamstveni / AMC Brodu
Warranty / AMC Status,Jamstveni / AMC Status
Warranty Expiry Date,Jamstvo Datum isteka
Warranty Period (Days),Jamstveno razdoblje (dani)
Warranty Period (in days),Jamstveno razdoblje (u danima)
Web Content,Web sadržaj
Web Page,Web stranica
Webforms,Web-obrasci
Website,Website
Website Description,Web stranica Opis
Website Home,Web stranica Početna
Website Item Group,Web stranica artikla Grupa
Website Item Groups,Website Stavka Grupe
Website Overall Settings,Website Ukupni Postavke
Website Price List,Web stranica Cjenik
Website Product Categories,Website Kategorije proizvoda
Website Product Category,Web Kategorija proizvoda
Website Script,Web Skripta
Website Settings,Website Postavke
Website Slideshow,Web Slideshow
Website Slideshow Item,Web Slideshow artikla
Website Warehouse,Web stranica galerije
Wednesday,Srijeda
Weekly,Tjedni
Weekly Off,Tjedni Off
Weight UOM,Težina UOM
Weightage,Weightage
Weightage (%),Weightage (%)
"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Kada bilo koji od provjerenih transakcija &quot;Postavio&quot;, e-mail pop-up automatski otvorio poslati e-mail na povezane &quot;Kontakt&quot; u toj transakciji, s transakcijom u privitku. Korisnik može ili ne može poslati e-mail."
"When you <b>Amend</b> a document after cancel and save it, it will get a new number that is a version of the old number.","Kada <b>Izmijeniti</b> dokument nakon otkazati i spasiti ga, on će dobiti novi broj koji je verzija starog broja."
Where items are stored.,Gdje predmeti su pohranjeni.
Where manufacturing operations are carried out.,Gdje proizvodni postupci provode.
White,Bijela boja
Widowed,Udovički
Width,Širina
Will be calculated automatically when you enter the details,Hoće li biti izračunata automatski kada unesete podatke
Will be fetched from Customer,Hoće li biti preuzeta od kupca
With Operations,Uz operacije
Work Done,Rad Done
Work In Progress,Radovi u tijeku
Workflow,Workflow
Workflow Action,Workflow Akcija
Workflow Action Detail,Workflow Akcija Detalj
Workflow Action Details,Workflow Akcija Detalji
Workflow Action Master,Workflow Akcija Master
Workflow Action Name,Workflow Akcija Ime
Workflow Document State,Workflow dokument Država
Workflow Document States,Workflow dokument Države
Workflow Engine,Workflow motora
Workflow Name,Workflow ime
Workflow Rule,Workflow Pravilo
Workflow Rule Detail,Workflow Pravilo Detalj
Workflow Rule Details,Workflow Pravilo Detalji
Workflow State,Workflow država
Workflow State Field,Workflow Državna polja
Workflow State Name,Workflow Država Ime
Workflow Transition,Tijek tranzicije
Workflow Transitions,Workflow Prijelazi
Workflow state represents the current state of a document.,Workflow država predstavlja trenutno stanje dokumenta.
Workflow will start after saving.,Workflow će početi nakon štednje.
Workfow,Workfow
Working,Rad
Workstation,Workstation
Workstation Name,Ime Workstation
Write,Pisati
Write Off Account,Napišite Off račun
Write Off Amount,Napišite paušalni iznos
Write Off Amount <=,Otpis Iznos &lt;=
Write Off Based On,Otpis na temelju
Write Off Cost Center,Otpis troška
Write Off Outstanding Amount,Otpisati preostali iznos
Write Off Voucher,Napišite Off bon
Year,Godina
Year Closed,Godina Zatvoreno
Year Name,Godina Ime
Year Start Date,Godina Datum početka
Year of Passing,Godina Prolazeći
Yearly,Godišnje
Yes,Da
Yesterday,Jučer
You are not authorized to do/modify back dated entries before ,Niste ovlašteni da ne / mijenjati natrag datirane unose prije
You can create more earning and deduction type from Setup --> HR,Možete stvoriti više plaća i dedukcije tipa iz Setup -&gt; HR
You can enter any date manually,Možete unijeti bilo koji datum ručno
You can enter the minimum quantity of this item to be ordered.,Možete unijeti minimalnu količinu ove točke biti naređeno.
You can make a delivery note from multiple sales orders. Select sales orders one by one and click on the button below.,"Možete napraviti bilješku isporuke iz više prodajnih naloga. Odaberite narudžbe, jednu po jednu i kliknite na gumb ispod."
You can make a purchase order from multiple Material Requests. Select Material Requests one by one and click on the button below.,Možete napraviti redoslijed kupnje od više materijala zahtjeva. Odaberite materijalni zahtijevi jedan po jedan i kliknite na gumb ispod.
You can make a purchase order from multiple Supplier Quotations. Select Supplier Quotations one by one and click on the button below.,Možete napraviti redoslijed kupnje iz više dobavljačima Citati. Odaberite dobavljač Citati jedan po jedan i kliknite na gumb ispod.
You can make a purchase receipt from multiple purchase orders. Select purchase orders one by one and click on the button below.,"Možete napraviti kupnju potvrdu iz više narudžbenice. Odaberite narudžbe, jednu po jednu i kliknite na gumb ispod."
You can set various 'properties' to Users to set default values and apply permission rules based on the value of these properties in various forms.,Možete postaviti različite &#39;Properties&#39; za korisnike postaviti zadane vrijednosti i primjenjivati ​​pravila dozvola na temelju vrijednosti tih svojstava u različitim oblicima.
You can use <a href='#Form/Customize Form'>Customize Form</a> to set levels on fields.,Možete koristiti <a href='#Form/Customize Form'>Prilagodite obrazac</a> za postavljanje razine na poljima.
Your Customer's TAX registration numbers (if applicable) or any general information,Vaš klijent je poreznoj registraciji brojevi (ako je primjenjivo) ili bilo opće informacije
"Your download is being built, this may take a few moments...","Vaš preuzimanje se gradi, to može potrajati nekoliko trenutaka ..."
Your letter head content in HTML.,Vaše pismo glava sadržaj u HTML.
Your sales person who will contact the customer in future,Vaš prodaje osobi koja će kontaktirati kupca u budućnosti
Your sales person who will contact the lead in future,Vaš prodaje osobi koja će kontaktirati vodstvo u budućnosti
Your sales person will get a reminder on this date to contact the customer,Vaš prodavač će dobiti podsjetnik na taj datum kontaktirati kupca
Your sales person will get a reminder on this date to contact the lead,Vaš prodavač će dobiti podsjetnik na taj datum da se obratite vodstvo
Your support email id - must be a valid email - this is where your emails will come!,Vaša podrška e-mail id - mora biti valjana e-mail - ovo je mjesto gdje svoje e-mailove će doći!
[],[]
add your own CSS (careful!),dodati svoj vlastiti CSS (careful!)
adjust,prilagoditi
align-center,poravnajte-centar
align-justify,poravnajte-opravdati
align-left,poravnajte-lijevo
align-right,poravnati desno
and,i
arrow-down,strelica prema dolje
arrow-left,strelica lijevo
arrow-right,Strelica desno
arrow-up,strelica prema gore
asterisk,zvjezdica
backward,natrag
ban-circle,zabrana-krug
barcode,barkod
bell,zvono
bold,odvažan
book,knjiga
bookmark,bookmark
briefcase,aktovka
bullhorn,bullhorn
calendar,kalendar
camera,kamera
cancel,otkazati
certificate,certifikat
check,provjeriti
chevron-down,Chevron-dolje
chevron-left,Chevron-lijevo
chevron-right,Chevron-desno
chevron-up,Chevron-up
circle-arrow-down,krug sa strelicom prema dolje
circle-arrow-left,krug sa strelicom nalijevo
circle-arrow-right,krug sa strelicom desno
circle-arrow-up,krug sa strelicom prema gore
cog,vršak
comment,komentirati
create a Custom Field of type Link (Profile) and then use the 'Condition' settings to map that field to the Permission rule.,"stvoriti Custom Field tipa Link (Profil), a zatim koristiti &#39;stanje&#39; postavke na karti koje polje na dozvole vladavine."
dashboard,kontrolna ploča
dd-mm-yyyy,dd-mm-yyyy
dd/mm/yyyy,dd / mm / gggg
deactivate,deaktivirati
does not belong to BOM: ,ne pripadaju sastavnice:
download,preuzimanje
download-alt,download-alt
"e.g. 0.5, 2.5 etc","npr. 0,5, 2,5 itd."
"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditne kartice"
"e.g. Kg, Unit, Nos, m","npr. kg, Jedinica, br, m"
"e.g. Office, Billing, Shipping","npr. ured, naplate, Dostava"
edit,urediti
eg. Cheque Number,npr.. Ček Broj
eject,izbaciti
english,engleski
envelope,omotnica
equal,jednak
español,español
exclamation-sign,usklik-znak
eye-close,oka u blizini
eye-open,oku-otvaranje
facetime-video,FaceTime-video
fast-backward,brzo unatrag
fast-forward,brzo naprijed
file,file
film,film
filter,filtriranje
fire,vatra
flag,zastava
folder-close,mapa-blizu
folder-open,mapa otvoriti
font,krstionica
forward,naprijed
français,français
fullscreen,fullscreen
gift,dar
glass,staklo
globe,globus
greater than,veći od
greater than equal,veće od jednako
hand-down,rukom prema dolje
hand-left,ruka-lijeva
hand-right,ruka-desna
hand-up,ruka-up
has been entered atleast twice,je ušao atleast dva puta
hdd,HDD
headphones,slušalice
heart,srce
home,dom
inbox,inbox
indent-left,alineje-lijevo
indent-right,alineje-desno
info-sign,info-znak
is a cancelled Item,je otkazan artikla
is not a Stock Item,nije kataloški artikla
is not allowed.,nije dopušteno.
italic,kurzivan
leaf,list
less than,manje od
less than equal,manje od jednako
lft,LFT
list,popis
list-alt,popis-alt
lock,zaključati
magnet,magnet
map-marker,Karta marker
minus,minus
minus-sign,minus znak
mm-dd-yyyy,dd-mm-yyyy
mm/dd/yy,dd / mm / gg
mm/dd/yyyy,dd / mm / gggg
move,premjestiti
music,glazba
nederlands,Nederlands
not equal,nije jednako
not within Fiscal Year,nije u fiskalnoj godini
of type Link,tipa Link
off,isključen
ok,u redu
ok-circle,ok-krug
ok-sign,ok-prijava
old_parent,old_parent
or,ili
pause,stanka
pencil,olovka
picture,slika
plane,avion
play,igrati
play-circle,play-krug
plus,plus
plus-sign,plus-potpisati
português,Português
print,tiskati
qrcode,qrcode
question-sign,pitanje-prijava
question-view,Pitanje-pogled
questions,pitanja
random,slučajan
reached its end of life on,dosegla svoj kraj života na
refresh,osvježiti
remove,ukloniti
remove-circle,uklanjanje-krug
remove-sign,uklanjanje-potpisati
repeat,ponoviti
resize-full,resize-pun
resize-horizontal,resize-horizontalna
resize-small,resize-mala
resize-vertical,resize-vertikalna
retweet,retweet
rgt,ustaša
road,cesta
screenshot,slike
search,traženje
share,udio
share-alt,Udio-alt
shopping-cart,shopping-cart
signal,signal
star,zvijezda
star-empty,zvijezda-prazna
step-backward,korak unatrag
step-forward,korak naprijed
stop,zaustaviti
tag,privjesak
tags,oznake
"target = ""_blank""",target = &quot;_blank&quot;
tasks,zadaci
test,test
text-height,tekst-visina
text-width,tekst širine
th,og
th-large,og veliki
th-list,og-popis
thumbs-down,palac dolje
thumbs-up,palac gore
time,vrijeme
tint,nijansa
to,na
to be dropped,se odustalo
trash,smeće
upload,upload
user,korisnik
user_image_show,user_image_show
values and dates,Vrijednosti i datumi
volume-down,glasnoće prema dolje
volume-off,volumen-off
volume-up,glasnoće prema gore
warning-sign,upozorenje-znak
website page link,web stranica vode
wrench,ključ
yyyy-mm-dd,gggg-mm-dd
zoom-in,zoom-u
zoom-out,zoom-out
српски,српски
العربية,العربية
हिंदी,हिंदी
தமிழ்,தமிழ்
