public async Task <IActionResult> Edit([Required][FromRoute] int id)
        {
            TeamMemberEditModel teamMemberEditModel = new TeamMemberEditModel();

            if (ModelState.IsValid)
            {
                try
                {
                    //Get member data all languages
                    IEnumerable <TeamMemberDto> teamMemberView = (await lawyerDbContext.GetTeamMembersViewAsync())
                                                                 .Where(m => m.Id == id)
                                                                 .OrderBy(m => m.LanguageId);
                    if (teamMemberView == null)
                    {
                        throw new InvalidOperationException();
                    }

                    //Mapping to view model
                    teamMemberEditModel.TeamMembers = teamMemberView.Select(m => new TeamMemberCreateModel
                    {
                        Name        = m.Name,
                        Surname     = m.Surname,
                        Description = m.Description,
                        LanguageId  = m.LanguageId
                    }).ToList();
                    var teammember = teamMemberView.FirstOrDefault();
                    teamMemberEditModel.Id        = id;
                    teamMemberEditModel.Begin     = teammember.Begin;
                    teamMemberEditModel.End       = teammember.End;
                    teamMemberEditModel.Languages = await lawyerDbContext.Languages
                                                    .AsNoTracking()
                                                    .ToListAsync();

                    teamMemberEditModel.Areas = (await lawyerDbContext.GetAreaViewAsync())
                                                .Where(m => m.LanguageId == DbContextService.GetLanguageIdByShortName(lawyerDbContext))?.ToList();

                    teamMemberEditModel.AreaId = lawyerDbContext.TeamToAreas.Where(m => m.TeamMemberId == id).Select(m => m.AreaId).ToList();

                    return(View(teamMemberEditModel));
                }
                catch (InvalidOperationException)
                {
                    return(RedirectToAction(nameof(Index)));
                }
            }

            return(RedirectToAction(nameof(Index)));
        }
        public async Task <IActionResult> Edit([Required][FromForm] int id, List <TeamMemberCreateModel> TeamMembers, IFormFile Img, byte Begin, byte End, List <int> AreaId)
        {
            if (ModelState.IsValid)
            {
                IDbContextTransaction transaction = null;
                try
                {
                    transaction = await lawyerDbContext.Database.BeginTransactionAsync();

                    TeamMember teamMember = await lawyerDbContext.TeamMembers.FindAsync(id);

                    var teamToAreas = lawyerDbContext.TeamToAreas.Where(m => m.TeamMemberId == id).ToList();

                    if (teamMember == null)
                    {
                        throw new NullReferenceException("This member doesn't exist !!!");
                    }

                    teamMember.Begin = Begin;
                    teamMember.End   = End;

                    if (Img != null)
                    {
                        string fileName = teamMember.Img;
                        teamMember.Img = await FileService.UploadImageAsync(Img, "Uploads");

                        FileService.DeleteFile(fileName, "Uploads");
                    }

                    lawyerDbContext.TeamToAreas.RemoveRange(teamToAreas);

                    IEnumerable <TeamToArea> teamToAreaInsert = AreaId.Select(m => new TeamToArea
                    {
                        AreaId       = m,
                        TeamMemberId = id
                    });

                    await lawyerDbContext.TeamToAreas.AddRangeAsync(teamToAreaInsert);

                    IEnumerable <Text> nameTextAllLanguage = await lawyerDbContext.Texts
                                                             .Where(m => m.Key == teamMember.NameKey)
                                                             .ToListAsync();

                    IEnumerable <Text> surnameTextAllLanguage = await lawyerDbContext.Texts
                                                                .Where(m => m.Key == teamMember.SurnameKey)
                                                                .ToListAsync();

                    IEnumerable <Text> descriptionTextAllLanguage = await lawyerDbContext.Texts
                                                                    .Where(m => m.Key == teamMember.DescriptionKey)
                                                                    .ToListAsync();

                    //Update texts all language for properties
                    foreach (var item in TeamMembers)
                    {
                        Text name = nameTextAllLanguage.SingleOrDefault(m => m.LanguageId == item.LanguageId);
                        name.TextContent = item.Name;
                        Text surname = surnameTextAllLanguage.SingleOrDefault(m => m.LanguageId == item.LanguageId);
                        surname.TextContent = item.Surname;
                        Text description = descriptionTextAllLanguage.SingleOrDefault(m => m.LanguageId == item.LanguageId);
                        description.TextContent = item.Description;
                    }

                    await lawyerDbContext.SaveChangesAsync();

                    transaction.Commit();

                    return(RedirectToAction(nameof(Index)));
                }

                catch (NullReferenceException exp)
                {
                    ModelState.AddModelError("", exp.Message);
                }

                catch (ArgumentNullException exp)
                {
                    ModelState.AddModelError("img", exp.Message);
                }

                catch (InvalidContentTypeException exp)
                {
                    ModelState.AddModelError("img", exp.Message);
                }
                catch
                {
                    transaction.Rollback();

                    ModelState.AddModelError("", "Some error occured !!!");
                }
                finally
                {
                    if (transaction != null)
                    {
                        transaction.Dispose();
                    }
                }
            }

            TeamMemberEditModel teamMemberEditModel = new TeamMemberEditModel
            {
                Id          = id,
                TeamMembers = TeamMembers,
                Img         = null,
                Languages   = await lawyerDbContext.Languages
                              .AsNoTracking()
                              .ToListAsync(),
                Areas = (await lawyerDbContext.GetAreaViewAsync())
                        .Where(m => m.LanguageId == DbContextService.GetLanguageIdByShortName(lawyerDbContext)).ToList(),
                AreaId = lawyerDbContext.TeamToAreas.Where(m => m.TeamMemberId == id).Select(m => m.AreaId).ToList()
            };

            return(View(teamMemberEditModel));
        }