Implémentation Golang de la logique de négociation

Les activités de négociation sont une forme de promotion populaire dans le commerce électronique et les plateformes sociales. Les participants peuvent obtenir des prix préférentiels pour des marchandises en marchandant dans un certain laps de temps. Toutefois, la mise en œuvre d’une logique de négociation des prix n’est pas simple et des questions telles que les relations entre les participants et le contrôle des prix doivent être prises en considération.

Cet article expliquera comment utiliser Golang pour mettre en œuvre une logique de négociation de prix.

1. La logique de base de la négociation

La logique de base de la négociation peut être résumée comme suit :

1. Créer une activité de négociation : l'initiateur de l'événement sélectionne un produit, fixe le prix initial et la période de négociation, et invite d'autres personnes à participer. en négociation.
2. Participer aux négociations : les participants à l'événement réduisent le prix des marchandises en lançant des négociations. La fourchette de négociation est déterminée aléatoirement par le système, mais ne sera pas inférieure à une valeur minimale.
3. Partager la négociation : les participants peuvent inviter davantage de personnes à participer à la négociation et augmenter leurs opportunités de négociation en partageant des liens de négociation.
4. Négociation réussie : lorsque le prix du produit descend à un certain niveau, la négociation est considérée comme réussie et l'utilisateur peut obtenir les remises correspondantes.

2. Golang implémente la logique de négociation

Nous allons maintenant présenter comment utiliser Golang pour mettre en œuvre la logique de négociation. Nous devons d'abord définir quelques structures de données :

1. Product information

type Product struct {

ID          int     // 商品ID
Name        string  // 商品名称
OriginalPrice   float32 // 商品原价
CurrentPrice    float32 // 当前价格
MinPriceDelta   float32 // 最小砍价幅度
MinPrice    float32 // 最低价格
Participants    map[int]*Participant // 参与者列表
ChoppedLogs map[int]float32 // 砍价日志
StartTime   time.Time // 开始时间
EndTime     time.Time // 结束时间

}

Parmi elles, Participants représente la liste des participants, ChoppedLogs enregistre l'étendue de chaque négociation par l'utilisateur et StartTime et EndTime représentent le cycle des prix.

2. Informations sur le participant

type Participant struct {

ID      int     // 参与者ID
Name    string  // 参与者名称
AmountChopped   float32 // 已砍金额
JoinedTime  time.Time // 加入时间
InviterID   int     // 邀请者ID
ProductID   int     // 商品ID
Invited     []*Participant // 被邀请人列表

}

Dans les informations sur le participant, AmountChopped indique le montant que le participant a coupé dans le produit actuel, InviterID enregistre l'ID de l'invitant et Invited enregistre l'invité liste de ceux-ci.

3. Journal de négociation

type ChoppedLog struct {

ParticipantID   int     // 砍价者ID
ChoppedAmount   float32 // 砍价金额
ProductID   int     // 商品ID
CreatedTime time.Time // 砍价时间

}

Dans le journal de négociation, l'identifiant du négociateur, le montant de la négociation, l'identifiant du produit et le temps de négociation sont enregistrés.

Avec la définition ci-dessus, nous pouvons écrire la logique de négociation suivante :

1. Créer une activité de négociation

func NewProduct(name string, originalPrice, minPriceDelta, minPrice float32, startTime, endTime time.Time) *Product {

return &Product{
    Name:           name,
    OriginalPrice:  originalPrice,
    CurrentPrice:   originalPrice,
    MinPriceDelta:  minPriceDelta,
    MinPrice:       minPrice,
    Participants:   make(map[int]*Participant),
    ChoppedLogs:    make(map[int]float32),
    StartTime:      startTime,
    EndTime:        endTime,
}

} 与 Participer à la bonne affaire

2. Func (P rproduct) Join (participant
Participant) Error {

R

if participant.JoinedTime.Before(p.StartTime) || participant.JoinedTime.After(p.EndTime) {
    return fmt.Errorf("参与时间错误")
}
if p.CurrentPrice <= p.MinPrice {
    return fmt.Errorf("价格已经到达最低价，不能再砍价了。")
}
id := len(p.Participants) + 1
participant.ID = id
participant.ProductID = p.ID
p.Participants[id] = participant
return nil

E

}

r

Func (P *Product) INVITE (PARTICIPANTID, Invite DID int) error {

3. if _, ok := p.Participants[participantID]; !ok {
       return fmt.Errorf("该用户未参加本次砍价活动")
   }
   if _, ok := p.Participants[invitedID]; !ok {
       return fmt.Errorf("该用户未在砍价活动中")
   }
   if participantID == invitedID {
       return fmt.Errorf("不允许自己邀请自己")
   }
   p.Participants[participantID].Invited = append(p.Participants[participantID].Invited, p.Participants[invitedID])
   p.Participants[invitedID].InviterID = participantID
   return nil

}

Négociation réussie

func (p *Product) Chop(participantID int) error {

4. if _, ok := p.Participants[participantID]; !ok {
       return fmt.Errorf("该用户未参加本次砍价活动")
   }
   if p.CurrentPrice <= p.MinPrice {
       return fmt.Errorf("提前到达底价，不能再砍价了。")
   }
   num := rand.Intn(10) // 随机砍价幅度
   chopAmount := p.MinPriceDelta + float32(num)
   if chopAmount >= p.CurrentPrice-p.MinPrice {
       chopAmount = p.CurrentPrice - p.MinPrice
   }
   p.CurrentPrice -= chopAmount
   p.Participants[participantID].AmountChopped += chopAmount
   p.ChoppedLogs[participantID] = chopAmount
   if p.CurrentPrice <= p.MinPrice {
       p.CurrentPrice = p.MinPrice
   }
   return nil

   }

   Grâce au code ci-dessus, nous pouvons implémenter une logique de négociation de base, y compris des opérations de base telles que la création d'activités de négociation , participer aux négociations, partager les négociations et les succès des négociations. Cependant, ces codes sont loin de répondre aux besoins d'applications pratiques, car nous devons également considérer les questions suivantes :

   Comment empêcher certains utilisateurs d'obtenir le prix le plus bas grâce à des négociations malveillantes ?
   Comment contrôler la fourchette de négociation pour que le prix fluctue dans une fourchette raisonnable ?
   1. Comment concevoir des règles de négociation et un mécanisme d'invitation afin que les activités de négociation puissent attirer davantage d'utilisateurs à participer ?
   2. Pour les problèmes ci-dessus, nous devons également les traiter en fonction des besoins spécifiques de l'entreprise.
   3. 3. Résumé

   La mise en œuvre de la logique de négociation via Golang peut nous permettre de mieux comprendre les principes de mise en œuvre des activités de négociation. Cependant, dans le développement réel, nous devons également prendre en compte d'autres problèmes, tels que le traitement simultané, la prévention des commandes frauduleuses, etc. Ces problèmes nous obligent également à traiter des scénarios commerciaux spécifiques. Je crois qu'avec une pratique continue, nous pouvons progressivement maîtriser les compétences de mise en œuvre des activités de négociation et apporter une plus grande contribution au développement du commerce électronique et des plateformes sociales.

   Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!