public override IEnumerable <object> Run()
        {
            GuildStorageManager storage = this.Entity.Storage;
            OnlineGuildMember   member  = this.Entity.GetOnlineMember(this.Operation.PuchasedCID);

            if (!this.Entity.Storage.Valid || !FeatureMatrix.IsEnable("GuildStorage"))
            {
                member.SendOperationFailedDialog("GuildStorageFail_Processing");
                storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Invalid);
                this.Finished = true;
                yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] GuildStorage")
                {
                    Reason = FailMessage.ReasonCode.LogicalFail
                });
            }
            else if (this.Entity.Storage.Processing)
            {
                member.SendOperationFailedDialog("GuildStorageFail_Processing");
                storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Processing);
                this.Finished = true;
                yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] Entity.Storage.Processing")
                {
                    Reason = FailMessage.ReasonCode.LogicalFail
                });
            }
            else if (!this.Entity.Storage.IsEnabled)
            {
                member.SendOperationFailedDialog("GuildStorageFail_Stopped");
                storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Invalid);
                this.Finished = true;
                yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] Entity.Storage.IsEnabled")
                {
                    Reason = FailMessage.ReasonCode.LogicalFail
                });
            }
            else if (storage.StorageCount >= storage.GuildStorageSlotsMax)
            {
                member.SendOperationFailedDialog("GuildStorageFail_Full");
                storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Invalid);
                this.Finished = true;
                yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] storage.StorageCount")
                {
                    Reason = FailMessage.ReasonCode.LogicalFail
                });
            }
            else
            {
                this.Entity.Storage.Processing = true;
                int targetSlotCount = 0;
                if (this.Entity.Storage.StorageCount == 0 && !FeatureMatrix.IsEnable("GuildStoargeSlotAllCash"))
                {
                    storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.PurchaseSlotByGold);
                    if (FeatureMatrix.GetInteger("GuildStorageSlotGoldPrice") > 0)
                    {
                        DestroyItem   op   = new DestroyItem("gold", FeatureMatrix.GetInteger("GuildStorageSlotGoldPrice"), GiveItem.SourceEnum.Unknown);
                        OperationSync sync = new OperationSync()
                        {
                            Connection = member.PlayerConn,
                            Operation  = (Operation)op
                        };
                        yield return((object)sync);

                        if (!sync.Result || !op.Result)
                        {
                            this.Entity.Storage.Processing = false;
                            storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.Error_PurchaseSlotByGold);
                            member.SendOperationFailedDialog("GuildStorageFail_PurchaseFailed");
                            this.Finished = true;
                            yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] op.Result")
                            {
                                Reason = FailMessage.ReasonCode.LogicalFail
                            });

                            yield break;
                        }
                    }
                    targetSlotCount = this.Entity.Storage.GuildStorageSlotsFirstPurchase;
                }
                else
                {
                    storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.PurchaseSlotByCash);
                    if (!FeatureMatrix.IsEnable("GuildStoargeSlotFree"))
                    {
                        if (this.Operation.ProductNo == -1)
                        {
                            member.SendOperationFailedDialog("GuildStorageFail_PurchaseFailed");
                            storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Invalid);
                            this.Entity.Storage.Processing = false;
                            this.Finished = true;
                            yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] Operation.ProductNo")
                            {
                                Reason = FailMessage.ReasonCode.LogicalFail
                            });

                            yield break;
                        }
                        else
                        {
                            DirectPickUpByProductNo op = new DirectPickUpByProductNo()
                            {
                                ProductNoList = new List <int>()
                                {
                                    this.Operation.ProductNo
                                },
                                IsCredit = this.Operation.IsCredit
                            };
                            OperationSync sync = new OperationSync()
                            {
                                Connection = member.CashShopConn,
                                Operation  = (Operation)op
                            };
                            yield return((object)sync);

                            if (!sync.Result || !op.Result || !op.ResultingItems.ContainsKey("guildstorage_ticket"))
                            {
                                storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.Error_PurchaseSlotByCash);
                                member.SendOperationFailedDialog("GuildStorageFail_PurchaseFailed");
                                this.Entity.Storage.Processing = false;
                                this.Finished = true;
                                yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] guildstorage_ticket")
                                {
                                    Reason = FailMessage.ReasonCode.LogicalFail
                                });

                                yield break;
                            }
                        }
                    }
                    targetSlotCount = this.Entity.Storage.GuildStorageSlotsPerPurchase;
                }
                storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.Process);
                AddGuildStorageSlots requestOp = new AddGuildStorageSlots()
                {
                    SlotCount = targetSlotCount
                };
                requestOp.OnComplete += (Action <Operation>)(___ => this.Entity.Storage.StorageCount = requestOp.ResultSlotCount);
                OperationSync sync2 = new OperationSync()
                {
                    Connection = this.Entity.Storage.ItemConn,
                    Operation  = (Operation)requestOp
                };
                yield return((object)sync2);

                if (requestOp.Result)
                {
                    storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.Done);
                }
                else
                {
                    storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.Error_ProcessFail);
                }
                this.Entity.Storage.Processing = false;
                this.Entity.Storage.ReportExtendSlot(member.CharacterName, this.Entity.Storage.GuildStorageSlotsPerPurchase);
                this.Finished = true;
                yield return((object)new OkMessage());
            }
        }
Example #2
0
        public override IEnumerable <object> Run()
        {
            base.Operation.Result = DirectPurchaseGuildItemResultCode.Success;
            GuildLedgerEventType result    = GuildLedgerEventType.Success;
            GuildMember          myInfo    = base.Entity.GetGuildMember(base.Operation.Key.CharacterName);
            OnlineGuildMember    member    = base.Entity.GetOnlineMember(myInfo.Key.CID);
            string maxIncreaseCountParsing = base.Operation.ItemClass.Replace("guild_extension_member_", "");
            int    maxIncreaseCount        = 0;

            if (!base.Entity.IsInitialized || base.Entity.GuildInfo == null)
            {
                base.Operation.Result = DirectPurchaseGuildItemResultCode.GuildNotInitialize;
                result = GuildLedgerEventType.GuildNotInitialize;
            }
            else if (myInfo == null || !myInfo.Rank.IsMaster() || member == null)
            {
                base.Operation.Result = DirectPurchaseGuildItemResultCode.IsNotMaster;
                result = GuildLedgerEventType.IsNotMaster;
            }
            else if (!int.TryParse(maxIncreaseCountParsing, out maxIncreaseCount))
            {
                base.Operation.Result = DirectPurchaseGuildItemResultCode.CannotParseItem;
                result = GuildLedgerEventType.CannotParseItem;
            }
            else if (FeatureMatrix.GetInteger("InGameGuild_MaxMemberLimit") < base.Entity.GuildInfo.MaxMemberCount + maxIncreaseCount)
            {
                base.Operation.Result = DirectPurchaseGuildItemResultCode.OverMaxMemberLimit;
                result = GuildLedgerEventType.OverMaxMemberLimit;
            }
            if (base.Operation.Result != DirectPurchaseGuildItemResultCode.Success)
            {
                GuildLog.AddGuildLedger(new LogData((long)base.Entity.GuildSN, base.Operation.Key.CID, OperationType.DirectPurchaseGuildItem, result));
                base.Finished = true;
                yield return(base.Operation.Result);
            }
            else
            {
                DirectPickUpByProductNo directPickupOp = new DirectPickUpByProductNo(new List <int>
                {
                    base.Operation.ProductNo
                }, base.Operation.IsCredit);
                OperationSync directPickupSync = new OperationSync
                {
                    Connection = member.CashShopConn,
                    Operation  = directPickupOp
                };
                yield return(directPickupSync);

                if (!directPickupSync.Result)
                {
                    if (directPickupOp.FailReasonString.StartsWith("BeginDirectPurchaseItem"))
                    {
                        base.Operation.Result = DirectPurchaseGuildItemResultCode.BeginDirectPurchaseItem;
                        result = GuildLedgerEventType.BeginDirectPurchaseItem;
                    }
                    else if (directPickupOp.FailReasonString.StartsWith("EndDirectPurchaseItem"))
                    {
                        base.Operation.Result = DirectPurchaseGuildItemResultCode.EndDirectPurchaseItem;
                        result = GuildLedgerEventType.EndDirectPurchaseItem;
                    }
                    else
                    {
                        base.Operation.Result = DirectPurchaseGuildItemResultCode.Unknown;
                        result = GuildLedgerEventType.Unknown;
                    }
                    GuildLog.AddGuildLedger(new LogData((long)base.Entity.GuildSN, base.Operation.Key.CID, OperationType.DirectPurchaseGuildItem, result));
                    base.Finished = true;
                    yield return(new FailMessage("[DirectPurchaseGuildItemProcessor] directPickupSync.Result"));
                }
                else
                {
                    bool updateResult = false;
                    try
                    {
                        HeroesDataContext heroesDataContext = new HeroesDataContext();
                        updateResult = heroesDataContext.UpdateMaxMemberLimit(base.Entity.GuildInfo.GuildSN, base.Entity.GuildInfo.MaxMemberCount + maxIncreaseCount);
                        if (!updateResult)
                        {
                            base.Operation.Result = DirectPurchaseGuildItemResultCode.DatabaseFail;
                            result = GuildLedgerEventType.DatabaseFail;
                        }
                    }
                    catch (Exception ex)
                    {
                        Log <DirectPurchaseGuildItemProcessor> .Logger.Error("UpdateGuildInfoProcessor DataBase Exception ", ex);

                        base.Operation.Result = DirectPurchaseGuildItemResultCode.DatabaseException;
                        result = GuildLedgerEventType.DatabaseException;
                    }
                    HeroesGuildInfo guildInfo = GuildAPI.GetAPI().GetGuildInfo(base.Entity.GuildSN);
                    if (guildInfo != null)
                    {
                        base.Entity.GuildInfo = guildInfo.ToGuildInfo();
                        base.Entity.UpdateGroupInfo();
                        base.Entity.Sync();
                    }
                    else
                    {
                        base.Operation.Result = DirectPurchaseGuildItemResultCode.ReloadFail;
                        result = GuildLedgerEventType.ReloadFail;
                    }
                    if (!updateResult || base.Operation.Result != DirectPurchaseGuildItemResultCode.Success)
                    {
                        RollbackDirectPickUp rollbackPickupOp = new RollbackDirectPickUp
                        {
                            OrderNo       = directPickupOp.OrderNo,
                            ProductNoList = directPickupOp.ProductNoList
                        };
                        OperationSync rollbackPickupSync = new OperationSync
                        {
                            Connection = member.CashShopConn,
                            Operation  = rollbackPickupOp
                        };
                        yield return(rollbackPickupSync);

                        Log <DirectPurchaseGuildItemProcessor> .Logger.ErrorFormat("UpdateGuildInfoProcessor DataBase Fail {0}", base.Entity.GuildSN);

                        GuildLog.AddGuildLedger(new LogData((long)base.Entity.GuildSN, base.Operation.Key.CID, OperationType.DirectPurchaseGuildItem, result));
                        base.Finished = true;
                        yield return(base.Operation.Result);
                    }
                    else
                    {
                        base.Operation.Result = DirectPurchaseGuildItemResultCode.Success;
                        result = GuildLedgerEventType.Success;
                        GuildLog.AddGuildLedger(new LogData((long)base.Entity.GuildSN, base.Operation.Key.CID, OperationType.DirectPurchaseGuildItem, result));
                        base.Finished = true;
                        yield return(base.Operation.Result);
                    }
                }
            }
            yield break;
        }