Modelando um gerenciador de contas em OOP

5

Eu tenho essa tarefa de modelar um sistema onde, dado um grupo de usuários, cada um pode acompanhar suas despesas. Os requisitos básicos são os seguintes:

  1. Para poder dar crédito a um usuário.
  2. Encontre todas as transações de um determinado usuário.
  3. Filtre a transação em que um dos usuários é mutuário ou gastador.
  4. Crie um grupo e coloque usuários nesse grupo e, quando um grupo for mencionado, distribua o dinheiro igualmente entre eles. [TODO]

Eu tentei algumas coisas, mas não estou convencido.

const trxn = new Array();

class Transaction {
    constructor(amount, from, to) {
      this.timestamp = new Date();
      this.amount = amount;
      this.from = from;
      this.to   = to;
      trxn.push(this);
    }

    toString() {
      let dd = this.timestamp.getDate();
      let mm = this.timestamp.getMonth();
      let yy = this.timestamp.getFullYear();
      return '[Transaction: ${dd}/${mm}/${yy}] ${this.from} Gives ${this.amount} to ${this.to}';
    }
}

class Person {
    constructor(name) {
      this.name = name;
      this._transactions = [];
    }

    transfer(amount, to) {
      let t = new Transaction(amount, this, to);
      this._transactions.push(t);
    }

    transactions() {
      return this._transactions;
    }

    toString() {
      return '${this.name.charAt(0).toUpperCase() + this.name.slice(1)}';
    }
}


function history(transactions, user) {
  return transactions.filter((t) => {
    return t.to.name === user.name || t.from.name === user.name;
  });
}


let amy = new Person('amy');
let foo = new Person('foo');
amy.transfer(500, foo);
amy.transfer(500, foo);
foo.transfer(200, amy);

for (let t of amy.transactions()) {
  console.log('Transaction by AMY');
  console.log(t);
}

for (let f of foo.transactions()) {
  console.log('Transaction by FOO');
  console.log(f);
}

console.log('Transaction history');
console.log(history(trxn, amy));

Saída da lógica acima:

Transaction by AMY
[Transaction: 22/10/2016] Amy Gives 500 to Foo
Transaction by AMY
[Transaction: 22/10/2016] Amy Gives 500 to Foo
Transaction by FOO
[Transaction: 22/10/2016] Foo Gives 200 to Amy
Transaction history
[Transaction: 22/10/2016] Amy Gives 500 to Foo,
[Transaction: 22/10/2016] Amy Gives 500 to Foo,
[Transaction: 22/10/2016] Foo Gives 200 to Amy

Como abordar problemas como esses? Eu li que apenas pensar sobre a lógica de negócios e não sobre os detalhes de implementação, portanto, no meu código não há menção de mecanismo de entrega e tudo mais.

Como posso tornar meu código mais flexível e robusto seguindo as práticas de POO?

    
por CodeYogi 22.11.2016 / 09:41
fonte

2 respostas

3

Isso soa como o problema contábil de livro duplo da conta bancária padrão. Não se deixe enganar por toda a conversa de Usuários, os objetos que você está modelando são contas e eles têm transações.

sempre que você faz um débito ou crédito, cria duas transações. ou seja, Amy dá Beth 100 dólares

Id,AccountId,Value
1,Amy,-100
2,Beth, +100

Se quiser, você pode adicionar um ID de link extra para fornecer o 'de onde vem o dinheiro' info

Id,AccountId,Value,LinkId
1,Amy,-100,1
2,Beth, +100,1
    
por 25.11.2016 / 11:18
fonte
1

O principal problema de design que eu vejo é isso

Transaction by AMY

Para chegar ao seu problema, você também precisará de uma variável para economizar a quantia de dinheiro que uma pessoa possui. Foo estava nessa transação, deveria colocar Transaction entre AMY e FOO, para tirar isso, você precisa remover a Transaction da classe Person, talvez dando uma ID para cada Person e toda vez que você fizer uma nova Transaction it poderia ser assim:

Transaction(Sender, Receiver, Amount)

t = new Transaction(4, 2, 500); //Person with ID 4 transfers 500 to Person with ID 2
transactions.push(t);

Para tornar as coisas mais simples, você deve ter um campo de dinheiro na sua classe Person. Não tenho muita certeza do que você quer dizer com:

Create a group and put users in that group and then when a group is mentioned then distribute money equally among them

Mas, para minha compreensão, você quer que um grupo divida seu dinheiro da seguinte forma:

P1 has $500

P2 has $400

P3 has $300

E você quer fazer P1 transferir $ 100 para P3, a fim de distribuir o dinheiro igualmente (é isso que eu entendo). para isso, você precisa obter a média (nesse caso 400) e fazer um loop sobre todos acima da média e transferir o dinheiro para baixo.

Aqui está outro caso:

P1 has $8

P2 has $7

P3 has $4

P4 has $1

Neste caso, a média é de $ 5, então P1 precisa ser transferido para P4, mas ele só pode transferir $ 3 para chegar à média, então ele transfere $ 3 para P4. Agora parece assim:

P1 has $5

P2 has $7

P3 has $4

P4 has $4

Agora, desde que P1 passou por P2 ($ 7) transferências para P4, mas apenas $ 1 para alcançar a média de $ 5, e como P2 tem $ 6, chegamos ao P3 e transferimos $ 1. Então as transações foram assim:

P1 transferred to P4 $3

P2 transferred to P4 $1

P2 transferred to P3 $1

Espero que isso ajude você!

    
por 01.12.2016 / 01:44
fonte