public async Task <PathMinDisplayed> CreatePath(PathModel path)
        {
            int           mapId  = 0;
            List <string> zones  = new List <string>();
            string        userId = User.Claims.First(c => c.Type == "UserID").Value;
            var           user   = await _userManager.FindByIdAsync(userId);

            TrajetDB trajetDB = new TrajetDB()
            {
                Name               = path.Name,
                Type               = (TypePath)path.Type,
                GroupLevelMax      = path.GroupLevelMax,
                GroupLevelMin      = path.GroupLevelMin,
                CaptureItem        = path.CaptureItem,
                Fk_User            = new Guid(userId),
                MaxPod             = path.MaxPod,
                MonsterQuantityMin = path.MonsterQuantityMin,
                MonsterQuantityMax = path.MonsterQuantityMax,
                LeaderBank         = path.LeaderBank,
                IsCapture          = path.IsCapture,
                ListRessource      = path.ListRessource,
                Key = Guid.NewGuid()
            };

            foreach (var monstreLevel in path.MonsterLevel)
            {
                if (trajetDB.MonsterLevel == null)
                {
                    trajetDB.MonsterLevel = new List <SpecificMonsterLevel>();
                }

                trajetDB.MonsterLevel.Add(new SpecificMonsterLevel()
                {
                    MonsterId       = monstreLevel.MonsterId,
                    MonsterLevelMax = monstreLevel.MonsterLevelmax,
                    MonsterLevelMin = monstreLevel.MonsterLevelMin
                });
            }
            foreach (var monstreQuantity in path.MonsterQuantity)
            {
                if (trajetDB.MonsterQuantity == null)
                {
                    trajetDB.MonsterQuantity = new List <SpecificMonsterQuantity>();
                }
                trajetDB.MonsterQuantity.Add(new SpecificMonsterQuantity()
                {
                    MonsterId          = monstreQuantity.MonsterId,
                    MonsterQuantityMax = monstreQuantity.MonsterQuantityMax,
                    MontserQuantityMin = monstreQuantity.MonsterQuantityMin
                });
            }
            foreach (var monstreCapture in path.MonsterCapture)
            {
                if (trajetDB.MonsterCapture == null)
                {
                    trajetDB.MonsterCapture = new List <CaptureMonsterQuantity>();
                }
                trajetDB.MonsterCapture.Add(new CaptureMonsterQuantity()
                {
                    MonsterId       = monstreCapture.MonsterId,
                    MonsterQuantity = monstreCapture.MonsterQuantity
                });
            }
            /* actions du trajet */
            trajetDB.PathAction = new List <PathAction>();
            foreach (PathActionModel action in path.PathAction)
            {
                PathAction pathActionToCreate = new PathAction();
                if (!ListBank.Contains(action.MapPos))
                {
                    MapDB map = Database.Maps.Find(o => o.Coordinate == ("[" + action.MapPos.Replace(';', ',') + "]")).First();

                    mapId = map.Key;
                    if (!zones.Contains(map.AreaName))
                    {
                        zones.Add(map.AreaName);
                    }

                    pathActionToCreate.MapId = mapId;
                    foreach (MapActionModel item in action.Actions)
                    {
                        if (pathActionToCreate.Actions == null)
                        {
                            pathActionToCreate.Actions = new List <MapAction>();
                        }

                        if (item.FightAction != null)
                        {
                            FightAction fightActionToCreate = new FightAction()
                            {
                                Order   = item.Order,
                                IsAlone = item.FightAction.IsAlone
                            };
                            pathActionToCreate.Actions.Add(fightActionToCreate);
                        }
                        else if (item.GatherAction != null)
                        {
                            GatherAction GatherActionToCreate = new GatherAction()
                            {
                                Order = item.Order
                            };
                            pathActionToCreate.Actions.Add(GatherActionToCreate);
                        }
                        else if (item.InteractionAction != null)
                        {
                            InteractionAction InteractionActionToCreate = new InteractionAction()
                            {
                                Order = item.Order,
                                InteractiveIdObject   = item.InteractionAction.InteractiveidObject,
                                InteractiveIdResponse = item.InteractionAction.InteractiveIdResponse,
                                ToBackBank            = item.InteractionAction.ToBackBank,
                                ToGoBank = item.InteractionAction.ToGoBank
                            };
                            pathActionToCreate.Actions.Add(InteractionActionToCreate);
                        }
                        else if (item.moveAction != null)
                        {
                            MoveAction MoveActionToCreate = new MoveAction()
                            {
                                Order      = item.Order,
                                ToBackBank = item.moveAction.ToBackBank,
                                ToGoBank   = item.moveAction.ToGoBank,
                                CellId     = item.moveAction.Cellid
                            };
                            if (item.moveAction.Direction != null)
                            {
                                foreach (string direc in item.moveAction.Direction)
                                {
                                    if (MoveActionToCreate.Direction == null)
                                    {
                                        MoveActionToCreate.Direction = new List <MovementDirectionEnum>();
                                    }
                                    MoveActionToCreate.Direction.Add((MovementDirectionEnum)System.Enum.Parse(typeof(MovementDirectionEnum), direc.ToUpper()));
                                }
                            }
                            pathActionToCreate.Actions.Add(MoveActionToCreate);
                        }
                        else if (item.UseItemAction != null)
                        {
                            UseItemAction UseItemActionToCreate = new UseItemAction()
                            {
                                Order      = item.Order,
                                ItemId     = item.UseItemAction.ItemId,
                                ToBackBank = item.UseItemAction.ToBackBank,
                                ToGoBank   = item.UseItemAction.ToGoBank
                            };
                            pathActionToCreate.Actions.Add(UseItemActionToCreate);
                        }
                        else if (item.ZaapAction != null)
                        {
                            int zaapDestination = Database.Maps.Find(o => o.Coordinate == ("[" + action.MapPos.Replace(';', ',') + "]")).First().Key;

                            ZaapAction UseItemActionctionToCreate = new ZaapAction()
                            {
                                Order       = item.Order,
                                Destination = zaapDestination,
                                ZaapId      = item.ZaapAction.ZaapId,
                                ToBackBank  = item.ZaapAction.ToBackBank,
                                ToGoBank    = item.ZaapAction.ToGoBank
                            };
                            pathActionToCreate.Actions.Add(UseItemActionctionToCreate);
                        }
                        else if (item.ZaapiAction != null)
                        {
                            int        zaapiDestination           = Database.Maps.Find(o => o.Coordinate == ("[" + action.MapPos.Replace(';', ',') + "]")).First().Key;
                            ZaapAction UseItemActionctionToCreate = new ZaapAction()
                            {
                                Order       = item.Order,
                                Destination = zaapiDestination,
                                ZaapId      = item.ZaapiAction.ZaapiId,
                                ToBackBank  = item.ZaapiAction.ToBackBank,
                                ToGoBank    = item.ZaapiAction.ToGoBank
                            };
                            pathActionToCreate.Actions.Add(UseItemActionctionToCreate);
                        }
                    }
                    trajetDB.PathAction.Add(pathActionToCreate);
                }
                else
                {
                    foreach (MapActionModel item in action.Actions)
                    {
                        pathActionToCreate = new PathAction();
                        if (item.moveAction != null)
                        {
                            mapId = item.moveAction.MapId.Value;
                            pathActionToCreate.MapId = mapId;
                            MoveAction MoveActionToCreate = new MoveAction()
                            {
                                Order      = item.Order,
                                ToBackBank = item.moveAction.ToBackBank,
                                ToGoBank   = item.moveAction.ToGoBank,
                                CellId     = item.moveAction.Cellid,
                                MapId      = mapId
                            };
                            if (item.moveAction.Direction != null)
                            {
                                foreach (string direc in item.moveAction.Direction)
                                {
                                    if (MoveActionToCreate.Direction == null)
                                    {
                                        MoveActionToCreate.Direction = new List <MovementDirectionEnum>();
                                    }
                                    MoveActionToCreate.Direction.Add((MovementDirectionEnum)System.Enum.Parse(typeof(MovementDirectionEnum), direc.ToUpper()));
                                }
                            }

                            if (trajetDB.PathAction.Exists(o => o.MapId == mapId))
                            {
                                trajetDB.PathAction.Find(o => o.MapId == mapId).Actions.Add(MoveActionToCreate);
                            }
                            else
                            {
                                pathActionToCreate.Actions = new List <MapAction>();
                                pathActionToCreate.Actions.Add(MoveActionToCreate);
                                trajetDB.PathAction.Add(pathActionToCreate);
                            }
                        }
                        else if (item.BankAction != null)
                        {
                            mapId = item.BankAction.MapId.Value;
                            pathActionToCreate.MapId = mapId;
                            BankAction BankActionToCreate = new BankAction()
                            {
                                MapId = mapId,
                                Order = item.Order
                            };
                            if (trajetDB.PathAction.Exists(o => o.MapId == mapId))
                            {
                                trajetDB.PathAction.Find(o => o.MapId == mapId).Actions.Add(BankActionToCreate);
                            }
                            else
                            {
                                pathActionToCreate.Actions = new List <MapAction>();
                                pathActionToCreate.Actions.Add(BankActionToCreate);
                                trajetDB.PathAction.Add(pathActionToCreate);
                            }
                        }
                    }
                }
            }
            trajetDB.Zones = zones;
            PathMinDisplayed retourPath = new PathMinDisplayed()
            {
                IsCapture  = trajetDB.IsCapture,
                Key        = trajetDB.Key,
                Name       = trajetDB.Name,
                Type       = trajetDB.Type,
                UsedNumber = 0,
                Zones      = trajetDB.Zones
            };

            await Database.Paths.InsertOneAsync(trajetDB);

            return(retourPath);
        }
Esempio n. 2
0
        // The logic and models depends on the file template
        private async void saveToDBAsync()
        {
            string templ = comboBox2?.SelectedItem?.ToString();

            switch (templ)
            {
            case "Процессы банка":
                await Task.Run(() =>
                {
                    List <string> bankDepartments = new List <string>();

                    // patterns for process code
                    string patternTheme   = @"^\w?[0-9]+$";                 // 2 hierarchy level
                    string patternAction  = @"^\w?[0-9]+\.[0-9]+$";         // 3 hierarchy level
                    string patternProcess = @"^\w?[0-9]+\.[0-9]+\.[0-9]+$"; // 4 hierarchy level
                    using (BankProcessContext bankProcessDB = new BankProcessContext())
                    {
                        // actual models object
                        // 1 hierarchy level
                        BankProcType bankProcType = null;
                        // 2 hierarchy level
                        BankTheme bankTheme = null;
                        // 3 hierarchy level
                        BankAction bankAction = null;
                        // 4 hierarchy level
                        BankProcess bankProcess = null;
                        // catalog
                        BankDepartment bankDepartment = null;
                        // file processing
                        foreach (BankProcCSV bankProc in filesLoaded[templ])
                        {
                            if (bankProc.Department == "")
                            {
                                if (bankProc.Id == "" &&
                                    bankProcessDB.BankProcTypes.FirstOrDefault(p => p.Name == bankProc.Name) == null)
                                {
                                    // Row to BankProcTypes (1 lvl)
                                    bankProcType = new BankProcType {
                                        Name = bankProc.Name
                                    };
                                    bankProcessDB.BankProcTypes.Add(bankProcType);
                                }
                                else
                                {
                                    if (Regex.IsMatch(bankProc.Id, patternTheme) &&
                                        bankProcessDB.BankThemes.FirstOrDefault(p => p.Code == bankProc.Id) == null)
                                    {
                                        // Row to BankThemes (2 lvl)
                                        bankTheme = new BankTheme {
                                            Name = bankProc.Name, Code = bankProc.Id, BankProcType = bankProcType
                                        };
                                        bankProcessDB.BankThemes.Add(bankTheme);
                                    }

                                    if (Regex.IsMatch(bankProc.Id, patternAction) &&
                                        bankProcessDB.BankActions.FirstOrDefault(p => p.Code == bankProc.Id) == null)
                                    {
                                        // Row to BankActions (3 lvl)
                                        bankAction = new BankAction {
                                            Name = bankProc.Name, Code = bankProc.Id, BankTheme = bankTheme
                                        };
                                        bankProcessDB.BankActions.Add(bankAction);
                                    }
                                }
                            }
                            else
                            {
                                if (bankProc.Id != "")
                                {
                                    if (Regex.IsMatch(bankProc.Id, patternProcess) &&
                                        bankProcessDB.BankProcesses.FirstOrDefault(p => p.Code == bankProc.Id) == null)
                                    {
                                        // Row to BankProcesses (4 lvl)
                                        if (!bankDepartments.Contains(bankProc.Department))
                                        {
                                            // Row to BankDepartments (catalog)
                                            bankDepartments.Add(bankProc.Department);
                                            bankDepartment = new BankDepartment {
                                                Name = bankProc.Department
                                            };
                                            bankProcessDB.BankDepartments.Add(bankDepartment);
                                        }
                                        else
                                        {
                                            bankDepartment = bankProcessDB.BankDepartments.FirstOrDefault(d => d.Name == bankProc.Department);
                                        }

                                        bankProcess = new BankProcess {
                                            Name = bankProc.Name, Code = bankProc.Id, BankAction = bankAction, BankDepartment = bankDepartment
                                        };
                                        bankProcessDB.BankProcesses.Add(bankProcess);
                                    }
                                }
                                else
                                {
                                    // Logic for empty Rows from file
                                }
                            }
                            bankProcessDB.SaveChanges();
                        }
                    }
                });

                comboBox1.Items.AddRange(new string[] { "BankProcTypes", "BankThemes", "BankActions", "BankProcesses", "BankDepartments" });
                comboBox1.SelectedItem = "BankProcesses";
                label6.Text            = "Файл сохранен в БД";
                break;

            default:
                label6.Text = "Укажите шаблон";
                break;
            }
        }
Esempio n. 3
0
        private static void ShowUserMenu(IUser user)
        {
            Console.Clear();
            Console.ForegroundColor = ConsoleColor.DarkGreen;
            Console.WriteLine("Меню пользователя:");
            Console.ResetColor();

            BankAction[] allowdActions;

            if (IsAdmin(user))
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine($"Вы залогинены под Админом.");
                Console.ResetColor();

                allowdActions = new BankAction[]
                {
                    BankAction.GetBalance,
                    BankAction.WithdrawMoney,
                    BankAction.DeleteUser,
                    BankAction.CheckUsers,
                    BankAction.ChangeMoney,
                    BankAction.EndWork
                };
            }
            else
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine($"Вы залогинены под Пользователем.");
                Console.ResetColor();

                allowdActions = new BankAction[]
                {
                    BankAction.GetBalance,
                    BankAction.WithdrawMoney,
                    BankAction.EndWork
                };
            }

            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("Выберите действие цифрой:");
            Console.ResetColor();

            while (true)
            {
                foreach (var item in allowdActions)
                {
                    Console.WriteLine($"[{(int)item}] {item}");
                }

                BankAction action = (BankAction)int.Parse(Console.ReadLine());

                if (!allowdActions.Contains(action))
                {
                    continue;
                }

                switch (action)
                {
                case BankAction.GetBalance:
                    Console.Clear();
                    Console.ForegroundColor = ConsoleColor.DarkGreen;
                    Console.WriteLine($"[Вы выбрали действие просмотра баланса]");
                    Console.ResetColor();
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine($"Сумма вашего баланса: {user.Balance.ToString()}$");
                    Console.ResetColor();
                    break;

                case BankAction.WithdrawMoney:
                    Console.Clear();
                    Console.ForegroundColor = ConsoleColor.DarkGreen;
                    Console.WriteLine($"[Вы выбрали действие снятия денег с баланса]\nСколько денег вы хотите снять?");
                    Console.ResetColor();

                    int.TryParse(Console.ReadLine(), out int widthrawMoney);

                    if (user.Balance <= 0)
                    {
                        Console.ForegroundColor = ConsoleColor.DarkRed;
                        Console.WriteLine($"У Вас больше не осталось денег.");
                        Console.ResetColor();
                        break;
                    }

                    if (widthrawMoney > user.Balance)
                    {
                        Console.ForegroundColor = ConsoleColor.DarkRed;
                        Console.WriteLine("Нельзя снять колличество большее вашего баланса");
                        Console.ResetColor();
                        break;
                    }

                    Console.ForegroundColor = ConsoleColor.Green;
                    user.Balance            = user.Balance - widthrawMoney;
                    Console.WriteLine($"Ваш остаток: {user.Balance}$");
                    Console.ResetColor();
                    break;

                case BankAction.DeleteUser:
                    Console.Clear();
                    Console.ForegroundColor = ConsoleColor.DarkGreen;
                    Console.WriteLine($"[Вы выбрали действие удаление пользователя]\nНапишите логин удаляемого пользователя");
                    Console.ResetColor();

                    if (UserStore.Users.Count() == 0)
                    {
                        Console.ForegroundColor = ConsoleColor.DarkRed;
                        Console.WriteLine($"Список логинов пуст!");
                        Console.ResetColor();
                        break;
                    }
                    else
                    {
                        for (int i = 0; i < UserStore.Users.Count(); i++)
                        {
                            if (UserStore.Users[i].IsDeleted == false)
                            {
                                Console.WriteLine($"{i}) Логин: {UserStore.Users[i].Login}");
                            }
                        }

                        (user as AdminUser).DeleteUser();
                    }
                    break;

                case BankAction.CheckUsers:
                    Console.Clear();
                    Console.ForegroundColor = ConsoleColor.DarkGreen;
                    Console.WriteLine($"[Вы выбрали действие проверки пользователей]");
                    Console.ResetColor();

                    if (UserStore.Users.Count() == 0)
                    {
                        Console.ForegroundColor = ConsoleColor.DarkRed;
                        Console.WriteLine($"Список логинов пуст!");
                        Console.ResetColor();
                        break;
                    }
                    else
                    {
                        for (int i = 0; i < UserStore.Users.Count(); i++)
                        {
                            if (UserStore.Users[i].IsDeleted == false)
                            {
                                Console.WriteLine($"{i}) Логин: {UserStore.Users[i].Login} | Баланс: {UserStore.Users[i].Balance}");
                            }
                        }
                    }
                    break;

                case BankAction.ChangeMoney:
                    Console.Clear();
                    Console.ForegroundColor = ConsoleColor.DarkGreen;
                    Console.WriteLine($"[Вы выбрали действие изменения баланса пользователю]");
                    Console.ResetColor();

                    if (UserStore.Users.Count() == 0)
                    {
                        Console.ForegroundColor = ConsoleColor.DarkRed;
                        Console.WriteLine($"Список логинов пуст!");
                        Console.ResetColor();
                        break;
                    }
                    else
                    {
                        for (int i = 0; i < UserStore.Users.Count(); i++)
                        {
                            if (UserStore.Users[i].IsDeleted == false)
                            {
                                Console.WriteLine($"{i}) Логин: {UserStore.Users[i].Login} | Баланс {UserStore.Users[i].Balance}");
                            }
                        }

                        (user as AdminUser).ChangeMoney();
                    }
                    break;

                case BankAction.EndWork:
                    return;
                }
            }
        }