public CompletedAuth(FlickrNet.Flickr flickrProxy, string frob)
 {
     InitializeComponent();
     _proxy = flickrProxy;
     this.Frob = frob;
     Load += new EventHandler(CompletedAuth_Load);
 }

        public void Login()
        {
            // Create Flickr instance
            m_flickr = new Flickr(API_KEY, SECRET);

            m_frob = m_flickr.AuthGetFrob();

            string flickrUrl = m_flickr.AuthCalcUrl(m_frob, AuthLevel.Write);

            // The following line will load the URL in the users default browser.
            System.Diagnostics.Process.Start(flickrUrl);

            bool bIsAuthorized = false;
            m_auth = new Auth();

            // do nothing until flickr authorizes.
            while (!bIsAuthorized)
            {
                try
                {
                    m_auth = m_flickr.AuthGetToken(m_frob);
                    m_flickr.AuthToken = m_auth.Token;
                }
                catch (FlickrException ex)
                {
                    ;
                }

                if (m_flickr.IsAuthenticated)
                {
                    bIsAuthorized = true;
                }
            }
        }

 public FlickrPhoto GetOnePhotoInfoFromFlickr(string photoId)
 {
     Flickr flickr = new Flickr(_apiKey, _secret);
     flickr.InstanceCacheDisabled = true;
     PhotoInfo photoInfo = new PhotoInfo();
     FlickrPhoto flickrPhoto = new FlickrPhoto();
     try
     {
         photoInfo = flickr.PhotosGetInfo(photoId);
         flickrPhoto.PictureId = photoInfo.PhotoId;
         flickrPhoto.OwnerName = !string.IsNullOrWhiteSpace(photoInfo.OwnerRealName) ? photoInfo.OwnerRealName : photoInfo.OwnerUserName;
         flickrPhoto.Title = photoInfo.Title;
         flickrPhoto.Description = photoInfo.Description;
         flickrPhoto.AvailablePublic = photoInfo.IsPublic;
         flickrPhoto.SmallImageUrl = photoInfo.Small320Url;
     }
     catch (Exception ex)
     {
         if (ex is PhotoNotFoundException)
         {
             flickrPhoto.AvailablePublic = false;
         }
     }
     return flickrPhoto;
 }

 public static int GetPagedSetCount(string setId)
 {
     Flickr flickr = new Flickr(ConfigurationManager.AppSettings["apiKey"],
         ConfigurationManager.AppSettings["sharedSecret"]);
     Photoset set = flickr.PhotosetsGetInfo(setId);
     return set.NumberOfPhotos;
 }

        public static PhotosetCollection GetPhotoSetsByUser(string userId)
        {
            Flickr flickr = new Flickr(ConfigurationManager.AppSettings["apiKey"],
                ConfigurationManager.AppSettings["sharedSecret"]);

            return flickr.PhotosetsGetList(userId);
        }

 private void ButtonPhoto_Click(object sender, EventArgs e)
 {
     var flickr = new Flickr(Program.ApiKey, Program.SharedSecret, Program.AuthToken);
     // Referrers
     DateTime day = DateTime.Today;
     var statfile = new System.IO.StreamWriter("stats_dom.csv");
     var reffile = new System.IO.StreamWriter("stats_referrers.csv");
     while (day > Program.LastUpdate)
     {
         try
         {
             var s = flickr.StatsGetPhotoDomains(day, 1, 100);
             day -= TimeSpan.FromDays(1);
             StatusLabel.Text = "Chargement des domaines " + day.ToShortDateString();
             Application.DoEvents();
             statfile.Write(Utility.toCSV(s, day.ToShortDateString()));
             foreach (StatDomain dom in s)
             {
                 var r = flickr.StatsGetPhotoReferrers(day, dom.Name, 1, 100);
                 reffile.Write(Utility.toCSV(r, day.ToShortDateString() + ";" + dom.Name));
             }
         }
         catch (FlickrApiException ex)
         {
             MessageBox.Show("Erreur lors du chargement des domaines référents du "
                 + day.ToShortDateString() + " : " + ex.OriginalMessage,
                 "Erreur", MessageBoxButtons.OK);
             break;
         }
     }
     statfile.Close();
 }

        private string UploadToFlickr(TideTrackerInputModel model)
        {
            string flickrId = string.Empty;

            var flickr = new Flickr(FlickrApiKey, FlickrApiSecret);

            //var oauthRequestToken = flickr.OAuthGetRequestToken("http://www.witnesskingtides.com/");
            //var ouathRequestToken = flickr.OAuthGetRequestToken("http://www.flickr.com/auth-72157638432779974");

            var client = new WebClient();
            var miniToken = client.DownloadString("http://www.flickr.com/auth-72157638432779974");

            //flickr = new Flickr(FlickrApiKey, FlickrApiSecret, oauthRequestToken.Token);

            //var auth = flickr.OAuthGetAccessToken(oauthRequestToken.Token, oauthRequestToken.TokenSecret, "72157638432779974");

            //var auth = flickr.AuthOAuthGetAccessToken();
            //using (var memoryStream = new MemoryStream())
            //{
            //    memoryStream.Write(model.Photo, 0, model.Photo.Length);

            //    flickrId = flickr.UploadPicture(memoryStream, model.FileName, null, model.Description, null, true, true, true, ContentType.Photo, SafetyLevel.None, HiddenFromSearch.Visible);
            //}

            return flickrId;
        }

        public string Upload(WitnessKingTidesApiInputModel model)
        {
            string flickrId = string.Empty;
            model.FileName = Guid.NewGuid().ToString() + ".jpg";

            var flickr = new Flickr(FlickrApiKey, FlickrApiSecret);
            flickr.OAuthAccessToken = FlickrOAuthKey;
            flickr.OAuthAccessTokenSecret = FlickrOAuthSecret;

            var path = Path.Combine(AppDataDirectory, model.FileName);
            using (var stream = File.OpenWrite(path))
            {
                stream.Write(model.Photo, 0, model.Photo.Length);
            }

            //TODO: We should probably fill the title here. Otherwise default flickr captions will be gibberish guids
            flickrId = flickr.UploadPicture(path, null, model.Description, null, true, false, false);

            //TODO: Should probably try/catch this section here. Failure to set location and/or delete the temp file should
            //not signal a failed upload.

            //TODO: Need to check if coordinates can be embedded in EXIF and extracted by Flickr. If so we can probably
            //skip this and embed the coordinates client-side.
            flickr.PhotosGeoSetLocation(flickrId, Convert.ToDouble(model.Latitude), Convert.ToDouble(model.Longitude));

            File.Delete(path);

            return flickrId;
        }

        public EffectGraphHomeView()
        {
            this.InitializeComponent();

            _flickr = new FlickrNet.Flickr(apiKey, apiSecret);

            PopupService.Init(layoutRoot);
 

            LoggingService.LogInformation("Showing splash screeen", "Views.HomeView");
            _vm = new HomeViewModel();
            _vm.Load();
            this.DataContext = _vm;

            //_vm.ShowLoginCommand.Execute(null);


            try
            {
                
                //Messenger.Default.Register<GeneralSystemWideMessage>(this, DoGeneralSystemWideMessageCallback);

                
            }
            catch { }


            //AppDatabase.Current.DeleteProjects(SessionID);


        }

        public IPhoto UploadPhoto(Stream stream, string filename, string title, string description, string tags)
        {
            using (MiniProfiler.Current.Step("FlickrPhotoRepository.UploadPhoto"))
            {
                Flickr fl = new Flickr();

                string authToken = (ConfigurationManager.AppSettings["FlickrAuth"] ?? "").ToString();
                if (string.IsNullOrEmpty(authToken))
                    throw new ApplicationException("Missing Flickr Authorization");

                fl.AuthToken = authToken;
                string photoID = fl.UploadPicture(stream, filename, title, description, tags, true, true, false,
                    ContentType.Photo, SafetyLevel.Safe, HiddenFromSearch.Visible);
                var photo = fl.PhotosGetInfo(photoID);
                var allSets = fl.PhotosetsGetList();
                var blogSet = allSets
                                .FirstOrDefault(s => s.Description == "Blog Uploads");
                if (blogSet != null)
                    fl.PhotosetsAddPhoto(blogSet.PhotosetId, photo.PhotoId);

                FlickrPhoto fphoto = new FlickrPhoto();
                fphoto.Description = photo.Description;
                fphoto.WebUrl = photo.MediumUrl;
                fphoto.Title = photo.Title;
                fphoto.Description = photo.Description;

                return fphoto;
            }
        }

 public IEnumerable<FlickrImage> GetImages(string tags)
 {
     Flickr.CacheDisabled = true;
     var flickr = new Flickr("340b341adedd9b2613d5c447c4541e0f");
     flickr.InstanceCacheDisabled = true;
     var options = new PhotoSearchOptions { Tags = tags, PerPage = 2  };
     var photos = flickr.PhotosSearch(options);
     return photos.Select(i =>
     {
         using (var client = new WebClient())
         {
             var data = client.DownloadData(i.Medium640Url);
             using (var memoryStream = new MemoryStream(data))
             {
                 var bitmap = new Bitmap(memoryStream);
                 return new FlickrImage
                            {
                                Url = i.Medium640Url,
                                Image = new Bitmap(bitmap),
                                Encoded = Convert.ToBase64String(memoryStream.ToArray())
                            };
             }
         }
     });
 }

        //
        // GET: /Photo/
        public ActionResult Set(string photosetID)
        {
            Flickr flickr = new Flickr(flickrKey, sharedSecret);
            PhotosetPhotoCollection photos = GetPhotosetPhotos(photosetID, flickr);

            return View(photos);
        }

 public static Flickr getFlickr()
 {
     Flickr f = new Flickr(Secrets.apiKey, Secrets.apiSecret);
     f.OAuthAccessToken = Settings.OAuthAccessToken;
     f.OAuthAccessTokenSecret = Settings.OAuthAccessTokenSecret;
     return f;
 }

        public FlickrHome()
        {
            this.InitializeComponent();

            _flickr = new FlickrNet.Flickr();
            CheckAlreadyExists();
        }

 public AccountController(IBoekService bs)
 {
     this.bs = bs;
     flickr = MvcApplication.flickr;
     if (flickr == null) flickr = FlickrApiManager.GetInstance();
 
 }

        public FlickrWrapper(Settings settings)
        {
            if (settings == null) throw new ArgumentNullException("settings");

            Settings = settings;
            Flickr = new Flickr(Settings.FlickrApiKey);
        }

        public void CheckApiKeyDoesNotThrowWhenPresent()
        {
            Flickr f = new Flickr();
            f.ApiKey = "X";

            Assert.DoesNotThrow(f.CheckApiKey);
        }

 public CompletedAuth(FlickrNet.Flickr flickrProxy, object frob)
 {
     InitializeComponent();
     _proxy = flickrProxy;
     Frob = frob;
     Load += CompletedAuth_Load;
 }

 public static void OpenAuthURL()
 {
     Flickr flickr = new Flickr(ApiKey, SharedSecret);
     frob = flickr.AuthGetFrob();
     AuthUrl = flickr.AuthCalcUrl(frob, AuthLevel.Write);
     System.Diagnostics.Process.Start(AuthUrl);
 }

 private void buttonStart_Click(object sender, EventArgs e)
 {
     // Create Flickr instance
     Flickr flickr = new Flickr(Program.ApiKey, Program.SharedSecret);
     try
     {
         // use the temporary Frob to get the authentication
         Auth auth = flickr.AuthGetToken(Program.tempFrob);
         // Store this Token for later usage,
         // or set your Flickr instance to use it.
         string info = "Authentification réussie\n" +
             "Utilisateur identifié: " + auth.User.UserName + "\n" +
             "L'identifiant pour cette session est " + auth.Token + "\n";
         Program.AuthToken = auth.Token;
         Program.Username = auth.User.UserName;
         MessageBox.Show(info, "Identification Flickr",
           MessageBoxButtons.OK, MessageBoxIcon.Information);
         Program.WriteConfig();
         Hide();
         var main_window = new MainForm();
         main_window.Show();
     }
     catch (FlickrException ex)
     {
         // If user did not authenticate your application
         // then a FlickrException will be thrown.
         string info = "L'authentification a échoué:\n" + ex.Message;
         MessageBox.Show(info, "Identification Flickr",
           MessageBoxButtons.OK, MessageBoxIcon.Error);
         // Quit application
         Application.Exit();
     }
 }