Cash register technical reference

  
addItem(type: string) { 
    this.transactionItems.push({ 
      eTransactionItemType: 'regular', 
      oType: { bRefund: false, bPrepayment: false },  
      quantity: 1, the quantity being purchased 
      price, the price of an article 
      nMargin: 1, margin of the supplier 
      nPurchasePrice: 0, 
      tax: tax, applicable tax on the product 
      nTotal: type === 'gold-purchase' ? -1 * price : price, total amount to be paid 
      paymentAmount: type === 'gold-purchase' ? -1 * price : 0,  actual paid amount 
    }); 
  } 
 
 

  
let taxDetails: any = await this.taxService.getLocationTax(iLocationId);
 
 

  
 distributeAmount(transactionItems: any[], availableAmount: any) { 
    transactionItems.forEach((i: any) => { 
here we process all the items and distribute money paid between them based on certain  
parameters like item type and refund etc. 
... 
    }); 
    return transactionItems; 
  } 
 
 

  
  createTransaction()  
  { 
The service will create the payload 
const body = this.tillService.createTransactionBody(transactionItems, payMethods,  
discountArticleGroup, redeemedLoyaltyPoints, customer); 
... 
An activity id serves as to keep track of current project 
body.oTransaction.iActivityId = this.iActivityId; 
Send to the backend 
this.apiService.postNew('cashregistry', '/api/v1/till/transaction', body) 
... 
  } 
 
 

  
createTransactionBody(<arguments>) { 
    const transaction = new Transaction( 
      	... 
eType: 'cash-register-revenue', 
... 
    ) 

const body = { 
      iBusinessId: currentBusiness, 
      iLocationId: currentLocation, 
      iWorkstationId: currentWorkstation, 
      transactionItems: transactionItems, 
      oTransaction: transaction,       
payments: this.getUsedPayMethods(false, payMethods),       
redeemedLoyaltyPoints, 
}; 

body.transactionItems = transactionItems.map((i: any) => { 
const bRefund = i.oType?.bRefund || i.nDiscount.quantity < 0 i.price < 0; 
      const bPrepayment =  
(bRefund && i.oType?.bPrepayment) ||  
( 
this.getUsedPayMethods(true, payMethods) - 	 
this.getTotals('price', transactionItems) < 0 
) ||  
(i.paymentAmount !== i.amountToBePaid) 
}); 

const oItem = new TransactionItem(); 

The selling price including vat rate 
oItem.nPriceIncVat = (i.type === 'gold-purchase') ? - (i.price) : i.price; 
 oItem.nEstimatedTotal = i.nTotal;     for repairs it is probable cost, can be change 
oItem.nPaymentAmount = i.paymentAmount; the actual amount paid by customer 
oItem.nPaidLaterAmount = 0;  amount that is agreed be paid later 
oItem.nRefundAmount = i.nRefundAmount;  
oItem.iActivityItemId = i.iActivityItemId;  
oItem.nVatRate = i.tax; applicable tax rate  
oItem.nRevenueAmount = i.paymentAmount / i.quantity; revenue generated per item 
 
process the loyalty point items (doing the same for discounts) 

if (redeemedLoyaltyPoints && redeemedLoyaltyPoints > 0) { 
      tItem1.oType.eTransactionType = 'cash-registry'; 
      tItem1.oType.eKind = 'loyalty-points-discount'; 
      tItem1.nPaymentAmount = -1 * redeemedLoyaltyPoints; 
      tItem1.nRevenueAmount = -1 * redeemedLoyaltyPoints; 
      tItem1.nRedeemedLoyaltyPoints = redeemedLoyaltyPoints; 
 
We create separate transaction item records for discount and loyalty points 

body.transactionItems.push(tItem1); 
} 
return body; 
} 
 
 

  
module.exports.createNewTransaction = async (transactionFactory, body, db, res) => { 

 const { oTransaction, transactionItems, giftCards } = body; 
const _Transaction = Transaction(db); 
const _Activity = Activity(db); 
const _oTransaction = _.pick(oTransaction, [ ... ] 

let oCreatedTransaction = new _Transaction(_oTransaction); 

if (!_oTransaction.iActivityId) { 
if this is new transaction then here we create new activity record 
oActivity = new _Activity(activityDetails); 
oCreatedTransaction.iActivityId = oActivity._id; 

Associate transaction with an activity 
oActivity.iTransactionId = oCreatedTransaction._id; 
     oActivity.eStatus = oCreatedTransaction.eStatus; 
    oActivity.eType = oTransaction.eType; 
    await oActivity.save(); 
} else { 
We are modifying existing activity - either refund or part payment 
oActivity = await _Activity.findById(_oTransaction.iActivityId);	 
} 

oTransaction.aTransactionItems = oTransaction.aTransactionItems.map((el) => { 
process transaction item data here 
}); 

oCreatedTransaction = await oCreatedTransaction.save(); 

In below method, we are handling transaction items and activity items 

const { activityItemPromiseArr, transactionItemPromiseArr, loyaltyPointsArr } = 
await this.createTransactionItems(oTransaction.aTransactionItems,receiptNumbers); 
 
let payments = body.payments.map((p) => ({ 
iPaymentMethodId: p._id, 
nAmount: p.amount, 
iTransactionId: oCreatedTransaction._id, 
iBusinessId: oTransaction.iBusinessId, 
iWorkstationId, 
iLocationId: oTransaction.iLocationId, 
sMethod: p.sName.toLowerCase(), 
}); 

payments = await Payments(db).create(payments); 
 
 

  
 module.exports.createTransactionItems = async (<arguments>) => { 
const _TransactionItem = TransactionItem(dbConnection); 
const _ActivityItems = ActivityItems(dbConnection); 
const _LoyaltyPoints = LoyaltyPoints(dbConnection); 

for (let index = 0; index < aTransactionItems.length; index++) { 

Using factory to handle data 
const transactionFactory = new TransactionFactory({ db: dbConnection });   
    const tItem = new _TransactionItem(transactionItem); 
    let tActivityItem = new _ActivityItems(transactionItem); 

 
if (!transactionItem.iActivityItemId) {  
no activity item id means this is a fresh transaction  
tActivityItem.nTotalAmount = (transactionItem.nPriceIncVat -  
transactionItem.nDiscount) * (transactionItem.nQuantity); 
       tActivityItem.nPaidAmount = transactionItem.nPaymentAmount; 
Associate transaction item with activity item 
tActivityItem.iTransactionItemId = tItem._id; 

Based on whether item is refund or prepaid, calculating the revenues 
if (transactionItem.oType.bRefund) { 
It is refund so it will generate negative revenue 
... 

tItem.nCostOfRevenue = -transactionItem.nPurchasePrice; 
tItem.nProfitOfRevenue = (transactionItem.nRevenueAmount +  
transactionItem.nDiscount) / (1 + transactionItem.nVatRate /  
100) + tItem.nCostOfRevenue; 
} else { 
Else it will generate positive revenue 
... 
tItem.nCostOfRevenue = transactionItem.nPurchasePrice; 
tItem.nProfitOfRevenue = (transactionItem.nRevenueAmount +  
transactionItem.nDiscount) / (1 + transactionItem.nVatRate /  
100) + tItem.nCostOfRevenue; 
} 

Assigning the same costs to an activity item also 
tActivityItem.nCostOfRevenue = tItem.nCostOfRevenue; 
tActivityItem.nProfitOfRevenue = tItem.nProfitOfRevenue; 
} else { We are modifying an existing activity item 

tActivityItem = _ActivityItems.findById(transactionItem.iActivityItemId); 
tActivityItem.nPaidAmount += transactionItem.nPaymentAmount 
 
Below we are checking all possible conditions based on refund and prepayment 
if (transactionItem.oType.bRefund 
&& tActivityItem.nPaidAmount === 0){ 
tActivityItem.bIsRefunded = true; 
} 

if (!transactionItem.oType.bRefund && transactionItem.oType.bPrepayment){ 
It is not refund but prepayment so calculate costs from partly paid amount 
tItem.nCostOfRevenue = transactionItem.nPurchasePrice; 
tItem.nProfitOfRevenue = (transactionItem.nRevenueAmount +  
transactionItem.nDiscount) / (1 + transactionItem.nVatRate /  
100) + tItem.nCostOfRevenue; 
} 

if (!transactionItem.oType.bRefund && !transactionItem.oType.bPrepayment) { 
It is neither refund nor prepayment means the complete rest of  
payment is done so calculate costs accordingly 
... 
} 

if (transactionItem.oType.bRefund && !transactionItem.oType.bPrepayment) { 
It is refund and fully paid so we reverse the complete transaction 

tItem.nCostOfRevenue = -tActivityItem.nCostOfRevenue; 
tItem.nProfitOfRevenue = ((transactionItem.nPriceIncVat -  
transactionItem.nDiscount) / (1 + transactionItem.nVatRate / 100) - 
transactionItem.nPurchasePrice) * -1; 
} 

if (transactionItem.oType.bRefund && transactionItem.oType.bPrepayment) { 
It is refund as well as only partly paid transaction so will reverse  
only paid amount and calculate costs accordingly 
... 
} 
             } 
} 

After processing all the items in above manner, we save it in transaction item 
tItem.nTotal = tActivityItem.nPaidAmount; 
tItem.nProfitOfRevenue = tItem.nProfitOfRevenue 

Here we do stock correction if needed 
if ( ( tActivityItem.nTotalAmount === tActivityItem.nPaidAmount ||  (transactionItem.oType.bRefund  &&
 tActivityItem.nPaidAmount === 0 ))  && transactionItem.oType.nStockCorrection && transactionItem.oType.eKind != 'reservation' ) { 

const nStockCorrection = transactionItem.oType.bRefund ? transactionItem.oType.nStockCorrection  : transactionItem.oType.nStockCorrection *-1; 
const stockCorrectionBody = { 
                    iBusinessId, 
                    iLocationId, 
                    iBusinessProductId, 
                    nStock: nStockCorrection, 
                    eType: 'sell', 
                    oReason,     
                    iProductId, 
                    iTransactionItemId: tItem?._id, 
                    oTransactionItem: tItem, 
                }; 

await _.axios('POST', stockCorrectionUrl, stockCorrectionBody, headers); 
} 
} 

 
 
 

  
File: till.component.ts 
  mapFiskalyData() { 
check if fiskaly is enabled for this business 
this.sTssId = await this.fiskalyService.fetchTSS(iBusinessId); 
if (this.sTssId)  
{  
we have TSS ID so fetch client  
const result: any = await this.fiskalyService.getClient(iBusinessId,iWorkstationId); 
this.fiskalyService.sClientId = result.data.clientInfo._id; 
this.fiskalyService.cancelFiskalyTransaction(this.transactionItems); 
} 
  } 
 
 

  
ile: fiskaly.service.ts 
  loginToFiskaly() { 
    this.fiskalyAuth = await this.apiService.postNew('fiskaly', '/api/v1/fiskaly/login',  
{iBusinessId}).toPromise(); 
  } 
 
 

  
  transactionItemObject(transactionItems: any) { 
    const amounts_per_vat_rate: any = []; 
    transactionItems.forEach((element: any) => { 
      ... 
Set vat rate and amount for each item 
      amounts_per_vat_rate.push({ 
        vat_rate: 'NORMAL', 
        amount: String(this.roundToXDigits(amount)), 
      }); 
    }); 
    return amounts_per_vat_rate; 
  } 
 
 

  
paymentObject(payment: any) { 
    const amounts_per_payment_type: any = []; 
  
    For cash 
    amounts_per_payment_type.push({ 
      payment_type: 'CASH', 
      amount: totalCashAmount, 
    }); 

    For non-cash payments 
    amounts_per_payment_type.push({ 
      payment_type: 'NON_CASH', 
      amount: totalNonCashAmount, 
    }); 
    return amounts_per_payment_type; 
  }  
 
 

  
 createSchema(transactionItems: any) { 
    const amounts_per_vat_rate = this.transactionItemObject(transactionItems); 
    const schema = { 
      standard_v1: { 
        receipt: { 
          receipt_type: 'RECEIPT', 
          amounts_per_vat_rate, 
          amounts_per_payment_type: [ 
            { payment_type: 'NON_CASH',amount: '0.00'},  
{ payment_type: 'CASH', amount: '0.00'} 
          ] 
        } 
      } 
    } 
    return schema; 
  } 
 
 

  
startTransaction() { 
    if (!this.fiskalyAuth) await this.loginToFiskaly(); 
    const guid = uuidv4(); generate unique id for this transaction 
    if (!this.tssId) this.fetchTSS(); fetch the tssId  
    const clientId = await this.getClientId(); fetch client id associated with this tssId 

    Prepare body to send to the fiskaly 
    const body = { 
      'state': 'ACTIVE', 
      'client_id': clientId 
    }; 

    const finalUrl = `${this.fiskalyURL}/tss/${this.tssId}/tx/${guid}?tx_revision=1`; 

    Sending data to the server 
    return await this.httpClient.put<any>(finalUrl, body, httpHeaders); 
  } 
 
 

  
  addItem(type: string) { 
... 
Process stock data here 
... 
await this.fiskalyService updateFiskalyTransaction('ACTIVE', []); 
  } 
 
 

  
  addOrder(product: any) { 
... 
Process order data here 
... 
this.fiskalyService updateFiskalyTransaction('ACTIVE', []) 
  } 
 
 

  
  itemChanged(item: any, index: number) { 
... 
Handle item change event data like update, delete, duplicate etc here	 
this.fiskalyService updateFiskalyTransaction('ACTIVE', []) 
  } 
 
 

  
updateFiskalyTransaction(transactionItems: any, payments: any, state: string) { 
const schema = this.createSchema(transactionItems); 
const fiskalyTransaction: any = JSON.parse(localStorage.getItem('fiskalyTransaction')); 
if (state === 'FINISHED') { 
      		const paymentObj = this.paymentObject(payments); 
   		schema.standard_v1.receipt.amounts_per_payment_type = paymentObj; 
} 
    const clientId = await this.getClientId(); 
    const body = { 
      state, 
      client_id: clientId, 
      schema  
    }; 
    ... 
    return await this.httpClient.put<any>(finalUrl, body, httpHeaders).toPromise(); 
  } 
 
 

  
changeTSSState(location: any, bEnabled: boolean, bRemoveFromLive: boolean = false) { 
    const body = { 
      bEnabled, 
      iTssId: location.iTssId, 
      bRemoveFromLive, 
      sLiveTssId: '', 
      fiskalyToken: '', 
      admin_puk : '' 
    }; 
    if (bRemoveFromLive) { 
      body.fiskalyToken = this.fiskalyAuth.access_token; 
      body.sLiveTssId = location.tssInfo._id; 
      body.admin_puk = location.tssInfo.admin_puk; 
    } 

    return await this.apiService.putNew('fiskaly', `/api/v1/tss/change-state/${iBusinessId}`,  
body).toPromise(); 
  } 
 
 

  
  cancelFiskalyTransaction() { 
    try { 
      if (localStorage.getItem('fiskalyTransaction')) { 
       await this.fiskalyService.updateFiskalyTransaction(this.transactionItems, [],  
'CANCELLED'); 
       localStorage.removeItem('fiskalyTransaction');    } 
    } catch (error) {      localStorage.removeItem('fiskalyTransaction');       this.fiskalyService.clearAll(); 
    } 
  }