Golang-Implementierung der Verhandlungslogik

Verhandlungsaktivitäten sind eine beliebte Werbeform im E-Commerce und auf sozialen Plattformen. Teilnehmer können durch Feilschen innerhalb eines bestimmten Zeitraums Vorzugspreise für Waren erzielen. Die Umsetzung der Preisverhandlungslogik ist jedoch nicht einfach und es müssen Aspekte wie die Beziehung zwischen den Teilnehmern und die Preiskontrolle berücksichtigt werden.

In diesem Artikel wird erläutert, wie Sie Golang zur Implementierung der Preisverhandlungslogik verwenden.

1. Die Grundlogik des Verhandelns

Die Grundlogik des Verhandelns lässt sich wie folgt zusammenfassen:

1. Erstellen Sie eine Verhandlungsaktivität: Der Initiator der Veranstaltung wählt ein Produkt aus, legt den ursprünglichen Preis und den Verhandlungszeitraum fest und lädt andere zur Teilnahme ein im Verhandeln.
2. An Verhandlungen teilnehmen: Veranstaltungsteilnehmer senken den Warenpreis, indem sie Verhandlungen einleiten. Die Verhandlungsspanne wird vom System zufällig bestimmt, liegt jedoch nicht unter einem Mindestwert.
3. Verhandlungen teilen: Teilnehmer können mehr Menschen zur Teilnahme an Verhandlungen einladen und ihre Verhandlungsmöglichkeiten erhöhen, indem sie Verhandlungslinks teilen.
4. Erfolgreiches Verhandeln: Wenn der Preis des Produkts auf ein bestimmtes Niveau sinkt, gilt das Verhandeln als erfolgreich und der Benutzer kann entsprechende Rabatte erhalten.

2. Golang implementiert Verhandlungslogik

Jetzt stellen wir vor, wie man Golang zur Implementierung von Verhandlungslogik verwendet. Zuerst müssen wir einige Datenstrukturen definieren:

1. Produktinformationen

Typ Produktstruktur {

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 // 结束时间

}

Unter diesen stellt Participants die Liste der Teilnehmer dar, ChoppedLogs zeichnet den Umfang jeder Verhandlung durch den Benutzer auf und StartTime und EndTime stellen den Chop-Preiszyklus dar.

2. Teilnehmerinformationen

Typ Teilnehmerstruktur {

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

}

In den Teilnehmerinformationen stellt AmountChopped den Betrag dar, den der Teilnehmer im aktuellen Produkt gekürzt hat, InviterID zeichnet die ID des Einladenden auf und Invited zeichnet die Eingeladenen auf Liste davon.

3. Verhandlungsprotokoll

Typ ChoppedLog struct {

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

}

Im Verhandlungsprotokoll werden die ID des Verhandlungspartners, der Verhandlungsbetrag, die Produkt-ID und die Verhandlungszeit aufgezeichnet.

Mit der obigen Definition können wir die folgende Verhandlungslogik schreiben:

1. Eine Verhandlungsaktivität erstellen

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,
}

} 与 Am Schnäppchen teilnehmen

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) Fehler {

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

}

Verhandeln erfolgreich

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

   }

   Durch den obigen Code können wir grundlegende Verhandlungslogik implementieren, einschließlich grundlegender Operationen wie dem Erstellen von Verhandlungsaktivitäten , Teilnahme an Verhandlungen, gemeinsame Nutzung von Verhandlungen und Verhandlungserfolg. Diese Codes erfüllen jedoch bei weitem nicht die Anforderungen praktischer Anwendungen, da wir auch die folgenden Probleme berücksichtigen müssen:

   Wie kann verhindert werden, dass einige Benutzer durch böswillige Verhandlungen den niedrigsten Preis für Waren erzielen?
   Wie kann man die Verhandlungsspanne steuern, damit der Preis in einem angemessenen Bereich schwankt?
   1. Wie gestaltet man Verhandlungsregeln und Einladungsmechanismen, damit Verhandlungsaktivitäten mehr Benutzer zur Teilnahme anregen können?
   2. Für die oben genannten Probleme müssen wir uns auch entsprechend den spezifischen Geschäftsanforderungen befassen.
   3. 3. Zusammenfassung

   Die Implementierung der Verhandlungslogik durch Golang kann es uns ermöglichen, die Umsetzungsprinzipien von Verhandlungsaktivitäten besser zu verstehen. In der tatsächlichen Entwicklung müssen wir jedoch auch andere Probleme berücksichtigen, z. B. die gleichzeitige Verarbeitung, die Verhinderung betrügerischer Bestellungen usw. Diese Probleme erfordern auch, dass wir uns mit bestimmten Geschäftsszenarien befassen. Ich glaube, dass wir durch kontinuierliche Praxis nach und nach die Umsetzungsfähigkeiten von Verhandlungsaktivitäten beherrschen und einen größeren Beitrag zur Entwicklung von E-Commerce und sozialen Plattformen leisten können.

   Das obige ist der detaillierte Inhalt vonGolang-Implementierung der Verhandlungslogik. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!