protected void btnSearch_Click(object sender, EventArgs e)
        {
            //lista spelarna
            IList <Inti_Athlete> players;

            using (var db = Global.GetConnection())
            {
                players = Searching.SearchForAthletes(db, SearchInput.Text);
            }

            grdPlayers.DataKeyNames = new string[] { "GUID" };
            grdPlayers.DataSource   = players;
            grdPlayers.DataBind();
        }
        public string[] CompletePlayers(string prefixText, int count)
        {
            string[] result = new string[count];

            IList <Inti_Athlete> players;

            using (var db = Global.GetConnection())
            {
                players = Searching.SearchForAthletes(db, prefixText);
            }

            prefixText = prefixText.ToLower();

            count  = (players.Count() > count) ? count : players.Count();
            result = new string[count];

            var i = 0;

            foreach (var athlete in players)
            {
                if (athlete.FirstName.ToLower().StartsWith(prefixText))
                {
                    result[i] = String.Format("{0} {1}", athlete.FirstName, athlete.LastName);
                }
                else
                {
                    if (athlete.LastName.ToLower().StartsWith(prefixText))
                    {
                        result[i] = String.Format("{0}, {1}", athlete.LastName, athlete.FirstName);
                    }
                }

                i++;

                if (i >= count)
                {
                    break;
                }
            }

            return(result);
        }
        private ImportAthleteAction GetOrCreateAthleteImportAction(Guid selectedTournament, PlayerDetails playerDetails)
        {
            var importAthleteAction = new ImportAthleteAction();

            try
            {
                //verify and get club
                var club = new ClubManagement(Global.ConnectionString, SessionProps).GetClubByCode(selectedTournament, playerDetails.ClubCode);

                //verify and get position
                Inti_Position position = null;
                if (!String.IsNullOrEmpty(playerDetails.PosCode))
                {
                    position = new CommonDataFetches(Global.ConnectionString, SessionProps).GetPosition(playerDetails.PosCode);
                }

                //try to get athlete
                var athlete = new AthleteManagement(Global.ConnectionString, SessionProps).GetAthleteByName(playerDetails.FirstName, playerDetails.LastName);

                importAthleteAction.AthleteIsStored = (athlete != null);

                if (athlete == null)
                {
                    //athlete is added with full name?
                    var searchString = String.IsNullOrEmpty(playerDetails.FirstName)
                                           ? playerDetails.LastName
                                           : String.Format("{0}, {1}", playerDetails.FirstName, playerDetails.LastName);
                    IList <Inti_Athlete> matchingAthletes;
                    using (var db = Global.GetConnection())
                    {
                        matchingAthletes = Searching.SearchForAthletes(db, searchString);
                    }


                    if (matchingAthletes.Count == 0)
                    {
                        //do we have position?
                        if (position != null)
                        {
                            //create new athlete
                            athlete           = new Inti_Athlete();
                            athlete.FirstName = playerDetails.FirstName;
                            athlete.LastName  = playerDetails.LastName;
                        }
                        else
                        {
                            importAthleteAction.Exception = new Exception("Ny spelare men position saknas. Ange med position");
                        }
                    }
                    else
                    {
                        if (matchingAthletes.Count == 1)
                        {
                            athlete = matchingAthletes[0];
                            importAthleteAction.ImportAction += "OBS, kontrollera namnet. ";
                        }
                        else
                        {
                            var message = "Flera spelare matchar namnet:";
                            foreach (var matchingAthlete in matchingAthletes)
                            {
                                message += (matchingAthlete.FirstName + " " + matchingAthlete.LastName).Trim() + ", ";
                            }
                            importAthleteAction.Exception = new Exception(message);
                        }
                    }
                }

                if (athlete != null)
                {
                    //is the athlete already in tournament?
                    var athleteClub = new AthleteManagement(Global.ConnectionString, SessionProps).GetAthleteClubByTournament(athlete.GUID,
                                                                                                                              selectedTournament);

                    importAthleteAction.AthleteClubIsStored   = (athleteClub != null);
                    importAthleteAction.AthleteClubIsUpToDate = true;
                    if (athleteClub == null)
                    {
                        if (position != null)
                        {
                            athleteClub = new Inti_AthleteClub();

                            athleteClub.Inti_Athlete  = athlete;
                            athleteClub.Inti_Club     = club;
                            athleteClub.Inti_Position = position;
                            athleteClub.Price         = playerDetails.Price;
                        }
                        else
                        {
                            importAthleteAction.Exception = new Exception("Befintlig spelare men position saknas. Ange med position");
                        }
                    }
                    else
                    {
                        importAthleteAction.AthleteClubIsUpToDate = (athleteClub.Inti_Club.GUID == club.GUID);

                        //new club
                        if (athleteClub.Inti_Club.GUID != club.GUID)
                        {
                            athleteClub.Inti_Club = club;
                        }

                        if (position != null && athleteClub.Inti_Position.GUID != position.GUID)
                        {
                            importAthleteAction.Exception = new Exception(String.Format("Changed position from {0} to {1}, is it the correct player?", athleteClub.Inti_Position.ShortName, position.ShortName));
                        }

                        if (athleteClub.Price != playerDetails.Price)
                        {
                            importAthleteAction.Exception =
                                new Exception(String.Format("Changed price from {0} to {1}, is it the correct player?",
                                                            athleteClub.Price, playerDetails.Price));
                        }
                    }


                    //set import action
                    importAthleteAction.ImportAction += GetImportAction(importAthleteAction);

                    importAthleteAction.AthleteClub = athleteClub;
                }
            }
            catch (Exception exception)
            {
                importAthleteAction.Exception = exception;
            }

            return(importAthleteAction);
        }