/// <summary>
/// UploadPicture method that does all the uploading work.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> object containing the pphoto to be uploaded.</param>
/// <param name="fileName">The filename of the file to upload. Used as the title if title is null.</param>
/// <param name="title">The title of the photo (optional).</param>
/// <param name="description">The description of the photograph (optional).</param>
/// <param name="tags">The tags for the photograph (optional).</param>
/// <param name="isPublic">false for private, true for public.</param>
/// <param name="isFamily">true if visible to family.</param>
/// <param name="isFriend">true if visible to friends only.</param>
/// <param name="contentType">The content type of the photo, i.e. Photo, Screenshot or Other.</param>
/// <param name="safetyLevel">The safety level of the photo, i.e. Safe, Moderate or Restricted.</param>
/// <param name="hiddenFromSearch">Is the photo hidden from public searches.</param>
/// <param name="callback">Callback method to call upon return of the response from Flickr.</param>
public void UploadPictureAsync(Stream stream, string fileName, string title, string description, string tags,
bool isPublic, bool isFamily, bool isFriend, ContentType contentType,
SafetyLevel safetyLevel, HiddenFromSearch hiddenFromSearch,
Action<FlickrResult<string>> callback)
{
CheckRequiresAuthentication();
var uploadUri = new Uri(UploadUrl);
var parameters = new Dictionary<string, string>();
if (title != null && title.Length > 0)
{
parameters.Add("title", title);
}
if (description != null && description.Length > 0)
{
parameters.Add("description", description);
}
if (tags != null && tags.Length > 0)
{
parameters.Add("tags", tags);
}
parameters.Add("is_public", isPublic ? "1" : "0");
parameters.Add("is_friend", isFriend ? "1" : "0");
parameters.Add("is_family", isFamily ? "1" : "0");
if (safetyLevel != SafetyLevel.None)
{
parameters.Add("safety_level", safetyLevel.ToString("D"));
}
if (contentType != ContentType.None)
{
parameters.Add("content_type", contentType.ToString("D"));
}
if (hiddenFromSearch != HiddenFromSearch.None)
{
parameters.Add("hidden", hiddenFromSearch.ToString("D"));
}
parameters.Add("api_key", apiKey);
if (!string.IsNullOrEmpty(OAuthAccessToken))
{
parameters.Remove("api_key");
OAuthGetBasicParameters(parameters);
parameters.Add("oauth_token", OAuthAccessToken);
string sig = OAuthCalculateSignature("POST", uploadUri.AbsoluteUri, parameters, OAuthAccessTokenSecret);
parameters.Add("oauth_signature", sig);
}
else
{
parameters.Add("auth_token", apiToken);
}
UploadDataAsync(stream, fileName, uploadUri, parameters, callback);
}
/// <summary>
/// UploadPicture method that does all the uploading work.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> object containing the pphoto to be uploaded.</param>
/// <param name="fileName">The filename of the file to upload. Used as the title if title is null.</param>
/// <param name="title">The title of the photo (optional).</param>
/// <param name="description">The description of the photograph (optional).</param>
/// <param name="tags">The tags for the photograph (optional).</param>
/// <param name="isPublic">false for private, true for public.</param>
/// <param name="isFamily">true if visible to family.</param>
/// <param name="isFriend">true if visible to friends only.</param>
/// <param name="contentType">The content type of the photo, i.e. Photo, Screenshot or Other.</param>
/// <param name="safetyLevel">The safety level of the photo, i.e. Safe, Moderate or Restricted.</param>
/// <param name="hiddenFromSearch">Is the photo hidden from public searches.</param>
/// <returns>The id of the photograph after successful uploading.</returns>
public string UploadPicture(Stream stream, string fileName, string title, string description, string tags,
bool isPublic, bool isFamily, bool isFriend, ContentType contentType,
SafetyLevel safetyLevel, HiddenFromSearch hiddenFromSearch)
{
CheckRequiresAuthentication();
var uploadUri = new Uri(UploadUrl);
var parameters = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(title))
{
parameters.Add("title", title);
}
if (!string.IsNullOrEmpty(description))
{
parameters.Add("description", description);
}
if (!string.IsNullOrEmpty(tags))
{
parameters.Add("tags", tags);
}
parameters.Add("is_public", isPublic ? "1" : "0");
parameters.Add("is_friend", isFriend ? "1" : "0");
parameters.Add("is_family", isFamily ? "1" : "0");
if (safetyLevel != SafetyLevel.None)
{
parameters.Add("safety_level", safetyLevel.ToString("D"));
}
if (contentType != ContentType.None)
{
parameters.Add("content_type", contentType.ToString("D"));
}
if (hiddenFromSearch != HiddenFromSearch.None)
{
parameters.Add("hidden", hiddenFromSearch.ToString("D"));
}
if (!string.IsNullOrEmpty(OAuthAccessToken))
{
OAuthGetBasicParameters(parameters);
parameters.Add("oauth_token", OAuthAccessToken);
string sig = OAuthCalculateSignature("POST", uploadUri.AbsoluteUri, parameters, OAuthAccessTokenSecret);
parameters.Add("oauth_signature", sig);
}
else
{
parameters.Add("api_key", apiKey);
parameters.Add("auth_token", apiToken);
}
string responseXml = UploadData(stream, fileName, uploadUri, parameters);
var t = new UnknownResponse();
((IFlickrParsable)t).Load(responseXml);
return(t.GetElementValue("photoid"));
}
/// <summary>
/// Sets the safety level and hidden property of a photo.
/// </summary>
/// <param name="photoId">The ID of the photos to set.</param>
/// <param name="safetyLevel">The new content type.</param>
/// <param name="hidden">The new hidden value.</param>
/// <param name="callback">Callback method to call upon return of the response from Flickr.</param>
public void PhotosSetSafetyLevelAsync(string photoId, SafetyLevel safetyLevel, HiddenFromSearch hidden, Action<FlickrResult<NoResponse>> callback)
{
CheckRequiresAuthentication();
Dictionary<string, string> parameters = new Dictionary<string, string>();
parameters.Add("method", "flickr.photos.setSafetyLevel");
parameters.Add("photo_id", photoId);
if (safetyLevel != SafetyLevel.None) parameters.Add("safety_level", safetyLevel.ToString("D"));
switch (hidden)
{
case HiddenFromSearch.Visible:
parameters.Add("hidden", "0");
break;
case HiddenFromSearch.Hidden:
parameters.Add("hidden", "1");
break;
}
GetResponseAsync<NoResponse>(parameters, callback);
}
/// <summary>
/// Gets a users public photos. Excludes private photos.
/// </summary>
/// <param name="userId">The user id of the user.</param>
/// <param name="page">The page to return. Defaults to page 1.</param>
/// <param name="perPage">The number of photos to return per page. Default is 100.</param>
/// <param name="extras">Which (if any) extra information to return. The default is none.</param>
/// <param name="safetyLevel">The safety level of the returned photos.
/// Unauthenticated calls can only return Safe photos.</param>
/// <param name="callback">Callback method to call upon return of the response from Flickr.</param>
public void PeopleGetPublicPhotosAsync(string userId, int page, int perPage, SafetyLevel safetyLevel, PhotoSearchExtras extras, Action<FlickrResult<PhotoCollection>> callback)
{
if (!IsAuthenticated && safetyLevel > SafetyLevel.Safe)
throw new ArgumentException("Safety level may only be 'Safe' for unauthenticated calls", "safetyLevel");
Dictionary<string, string> parameters = new Dictionary<string, string>();
parameters.Add("method", "flickr.people.getPublicPhotos");
parameters.Add("api_key", apiKey);
parameters.Add("user_id", userId);
if (perPage > 0) parameters.Add("per_page", perPage.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
if (page > 0) parameters.Add("page", page.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
if (safetyLevel != SafetyLevel.None) parameters.Add("safety_level", safetyLevel.ToString("D"));
if (extras != PhotoSearchExtras.None) parameters.Add("extras", UtilityMethods.ExtrasToString(extras));
GetResponseAsync<PhotoCollection>(parameters, callback);
}
public void PhotosSetSafetyLevel(string photoId, SafetyLevel safetyLevel)
{
PhotosSetSafetyLevel(photoId, safetyLevel, HiddenFromSearch.None);
}
public PhotoCollection PeopleGetPublicPhotos(string userId, int page, int perPage, SafetyLevel safetyLevel)
{
return PeopleGetPublicPhotos(userId, page, perPage, safetyLevel, PhotoSearchExtras.None);
}
public PhotoCollection PeopleGetPublicPhotos(string userId, int page, int perPage, SafetyLevel safetyLevel, PhotoSearchExtras extras)
{
var dictionary = new Dictionary<string, string>();
dictionary.Add("method", "flickr.people.getPublicPhotos");
dictionary.Add("user_id", userId);
if (page != 0) dictionary.Add("page", page.ToString(CultureInfo.InvariantCulture));
if (perPage != 0) dictionary.Add("per_page", perPage.ToString(CultureInfo.InvariantCulture));
if (safetyLevel != SafetyLevel.None) dictionary.Add("safety_level", safetyLevel.ToString("d"));
if (extras != PhotoSearchExtras.None) dictionary.Add("extras", UtilityMethods.ExtrasToString(extras));
return GetResponse<PhotoCollection>(dictionary);
}
/// <summary>
/// UploadPicture method that does all the uploading work.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> object containing the pphoto to be uploaded.</param>
/// <param name="fileName">The filename of the file to upload. Used as the title if title is null.</param>
/// <param name="title">The title of the photo (optional).</param>
/// <param name="description">The description of the photograph (optional).</param>
/// <param name="tags">The tags for the photograph (optional).</param>
/// <param name="isPublic">false for private, true for public.</param>
/// <param name="isFamily">true if visible to family.</param>
/// <param name="isFriend">true if visible to friends only.</param>
/// <param name="contentType">The content type of the photo, i.e. Photo, Screenshot or Other.</param>
/// <param name="safetyLevel">The safety level of the photo, i.e. Safe, Moderate or Restricted.</param>
/// <param name="hiddenFromSearch">Is the photo hidden from public searches.</param>
/// <returns>The id of the photograph after successful uploading.</returns>
async public Task<string> UploadPicture(string fullPath, IProgress<UploadProgressChangedEventArgs> progress, string title = "", string description = "", string tags = "", bool isPublic = false, bool isFamily = true, bool isFriend = false, ContentType contentType = ContentType.None, SafetyLevel safetyLevel = SafetyLevel.Restricted, HiddenFromSearch hiddenFromSearch = HiddenFromSearch.Hidden)
{
CheckRequiresAuthentication();
string fileName = Path.GetFileName(fullPath);
using (Stream stream = new FileStream(fullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
Uri uploadUri = new Uri(UploadUrl);
Dictionary<string, string> parameters = new Dictionary<string, string>();
if (string.IsNullOrEmpty(title))
{ }
else
{ parameters.Add("title", title); }
if (string.IsNullOrEmpty(description))
{ }
else
{ parameters.Add("description", description); }
if (string.IsNullOrEmpty(tags))
{ }
else { parameters.Add("tags", tags); }
parameters.Add("is_public", isPublic ? "1" : "0");
parameters.Add("is_friend", isFriend ? "1" : "0");
parameters.Add("is_family", isFamily ? "1" : "0");
if (safetyLevel != SafetyLevel.None)
{
parameters.Add("safety_level", safetyLevel.ToString("D"));
}
if (contentType != ContentType.None)
{
parameters.Add("content_type", contentType.ToString("D"));
}
if (hiddenFromSearch != HiddenFromSearch.None)
{
parameters.Add("hidden", hiddenFromSearch.ToString("D"));
}
OAuthGetBasicParameters(parameters);
string sig = OAuthCalculateSignature("POST", uploadUri.AbsoluteUri, parameters, OAuthAccessTokenSecret);
parameters.Add("oauth_signature", sig);
//string responseXml = UploadData(stream, fileName, uploadUri, parameters);
string responseXml = await UploadData(stream, fullPath, uploadUri, parameters, progress);
var r = "";
if (string.IsNullOrEmpty(responseXml))
{
}
else
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
XmlReader reader = XmlReader.Create(new StringReader(responseXml), settings);
if (!reader.ReadToDescendant("rsp"))
{
throw new XmlException("Unable to find response element 'rsp' in Flickr response");
}
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "stat" && reader.Value == "fail")
throw new Exception();
//TODO:
//throw ExceptionHandler.CreateResponseException(reader);
continue;
}
reader.MoveToElement();
reader.Read();
UnknownResponse t = new UnknownResponse();
((IFlickrParsable)t).Load(reader);
stream.Close();
r = t.GetElementValue("photoid");
}
return r;
}
}
/// <summary>
/// UploadPicture method that does all the uploading work.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> object containing the pphoto to be uploaded.</param>
/// <param name="fileName">The filename of the file to upload. Used as the title if title is null.</param>
/// <param name="title">The title of the photo (optional).</param>
/// <param name="description">The description of the photograph (optional).</param>
/// <param name="tags">The tags for the photograph (optional).</param>
/// <param name="isPublic">false for private, true for public.</param>
/// <param name="isFamily">true if visible to family.</param>
/// <param name="isFriend">true if visible to friends only.</param>
/// <param name="contentType">The content type of the photo, i.e. Photo, Screenshot or Other.</param>
/// <param name="safetyLevel">The safety level of the photo, i.e. Safe, Moderate or Restricted.</param>
/// <param name="hiddenFromSearch">Is the photo hidden from public searches.</param>
/// <param name="callback">Callback method to call upon return of the response from Flickr.</param>
public void UploadPictureAsync(Stream stream, string fileName, string title, string description, string tags, bool isPublic, bool isFamily, bool isFriend, ContentType contentType, SafetyLevel safetyLevel, HiddenFromSearch hiddenFromSearch, Action <FlickrResult <string> > callback)
{
CheckRequiresAuthentication();
Uri uploadUri = new Uri(UploadUrl);
Dictionary <string, string> parameters = new Dictionary <string, string>();
if (title != null && title.Length > 0)
{
parameters.Add("title", title);
}
if (description != null && description.Length > 0)
{
parameters.Add("description", description);
}
if (tags != null && tags.Length > 0)
{
parameters.Add("tags", tags);
}
parameters.Add("is_public", isPublic ? "1" : "0");
parameters.Add("is_friend", isFriend ? "1" : "0");
parameters.Add("is_family", isFamily ? "1" : "0");
if (safetyLevel != SafetyLevel.None)
{
parameters.Add("safety_level", safetyLevel.ToString("D"));
}
if (contentType != ContentType.None)
{
parameters.Add("content_type", contentType.ToString("D"));
}
if (hiddenFromSearch != HiddenFromSearch.None)
{
parameters.Add("hidden", hiddenFromSearch.ToString("D"));
}
parameters.Add("api_key", apiKey);
if (!String.IsNullOrEmpty(OAuthAccessToken))
{
parameters.Remove("api_key");
OAuthGetBasicParameters(parameters);
parameters.Add("oauth_token", OAuthAccessToken);
string sig = OAuthCalculateSignature("POST", uploadUri.AbsoluteUri, parameters, OAuthAccessTokenSecret);
parameters.Add("oauth_signature", sig);
}
else
{
parameters.Add("auth_token", apiToken);
}
UploadDataAsync(stream, fileName, uploadUri, parameters, callback);
}
public string UploadPicture(Stream stream, string fileName, string title, string description, string tags,
bool isPublic, bool isFamily, bool isFriend, ContentType contentType,
SafetyLevel safetyLevel, HiddenFromSearch hiddenFromSearch);
public void PhotosSetSafetyLevel(string photoId, SafetyLevel safetyLevel, HiddenFromSearch hidden);
public void PhotosSetSafetyLevel(string photoId, SafetyLevel safetyLevel);
public PhotoCollection PeopleGetPhotos(string userId, SafetyLevel safeSearch, DateTime minUploadDate,
DateTime maxUploadDate, DateTime minTakenDate, DateTime maxTakenDate,
ContentTypeSearch contentType, PrivacyFilter privacyFilter,
PhotoSearchExtras extras, int page, int perPage);
public PhotoCollection PeopleGetPublicPhotos(string userId, int page, int perPage, SafetyLevel safetyLevel,
PhotoSearchExtras extras);
/// <summary>
/// Sets the safety level and hidden property of a photo.
/// </summary>
/// <param name="photoId">The ID of the photos to set.</param>
/// <param name="safetyLevel">The new content type.</param>
/// <param name="hidden">The new hidden value.</param>
public void PhotosSetSafetyLevel(string photoId, SafetyLevel safetyLevel, HiddenFromSearch hidden)
{
CheckRequiresAuthentication();
Hashtable parameters = new Hashtable();
parameters.Add("method", "flickr.photos.setSafetyLevel");
parameters.Add("photo_id", photoId);
if( safetyLevel != SafetyLevel.None ) parameters.Add("safety_level", (int)safetyLevel);
switch(hidden)
{
case HiddenFromSearch.Visible:
parameters.Add("hidden", 0);
break;
case HiddenFromSearch.Hidden:
parameters.Add("hidden", 1);
break;
}
FlickrNet.Response response = GetResponseNoCache(parameters);
if( response.Status == ResponseStatus.OK )
{
return;
}
else
{
throw new FlickrApiException(response.Error);
}
}
/// <summary>
/// Set the safety level for a photo.
/// </summary>
/// <param name="photoId">The ID of the photo to set the safety level property for.</param>
/// <param name="safetyLevel">The new value of the safety level value.</param>
/// <param name="callback">Callback method to call upon return of the response from Flickr.</param>
public async Task<FlickrResult<NoResponse>> PhotosSetSafetyLevelAsync(string photoId, SafetyLevel safetyLevel)
{
return await PhotosSetSafetyLevelAsync(photoId, safetyLevel, HiddenFromSearch.None);
}
public static async Task<string> UploadPictureAsync(Stream stream, string filename, string title, string description, string tags, bool isPublic, bool isFamily, bool isFriend, ContentType contentType, SafetyLevel safetyLevel, HiddenFromSearch hiddenFromSearch)
{
var parameters = new Dictionary<string, string>();
if (!string.IsNullOrEmpty(title))
{
parameters.Add("title", title);
}
if (!string.IsNullOrEmpty(description))
{
parameters.Add("description", description);
}
if (!string.IsNullOrEmpty(tags))
{
parameters.Add("tags", tags);
}
parameters.Add("is_public", isPublic ? "1" : "0");
parameters.Add("is_friend", isFriend ? "1" : "0");
parameters.Add("is_family", isFamily ? "1" : "0");
if (safetyLevel != SafetyLevel.None)
{
parameters.Add("safety_level", safetyLevel.ToString("D"));
}
if (contentType != ContentType.None)
{
parameters.Add("content_type", contentType.ToString("D"));
}
if (hiddenFromSearch != HiddenFromSearch.None)
{
parameters.Add("hidden", hiddenFromSearch.ToString("D"));
}
FlickrResponder.OAuthGetBasicParameters(parameters);
parameters.Add("oauth_consumer_key", Secrets.apiKey);
parameters.Add("oauth_token", Settings.OAuthAccessToken);
parameters.Add("oauth_signature", OAuthCalculateSignature("POST", UploadUrl, parameters, Settings.OAuthAccessTokenSecret));
string boundary = FlickrResponder.CreateBoundary();
string oauthHeader = FlickrResponder.OAuthCalculateAuthHeader(parameters);
string contentTypeHeader = "multipart/form-data; boundary=" + boundary;
string response;
FileStream data = FlickrResponder.CreateUploadData(stream, filename, parameters, boundary);
try
{
response = await FlickrResponder.UploadDataHttpWebRequestAsync(UploadUrl, data, contentTypeHeader, oauthHeader);
}
finally
{
data.Close();
File.Delete(data.Name);
data.Dispose();
}
Match match = Regex.Match(response, "<photoid>(\\d+)</photoid>");
if (match.Success)
{
return match.Groups[1].Value;
}
using (var reader = XmlReader.Create(new StringReader(response), new XmlReaderSettings { IgnoreWhitespace = true }))
{
if (!reader.ReadToDescendant("rsp"))
{
throw new XmlException("Unable to find response element 'rsp' in Flickr response");
}
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "stat" && reader.Value == "fail")
throw ExceptionHandler.CreateResponseException(reader);
}
}
throw new FlickrException("Unable to determine photo id from upload response: " + response);
}
public PhotoCollection PeopleGetPhotos(string userId, SafetyLevel safeSearch, DateTime? minUploadDate, DateTime? maxUploadDate, DateTime? minTakenDate, DateTime? maxTakenDate, ContentTypeSearch contentType, PrivacyFilter privacyFilter, PhotoSearchExtras extras, int page, int perPage)
{
var dictionary = new Dictionary<string, string>();
dictionary.Add("method", "flickr.people.getPhotos");
dictionary.Add("user_id", userId);
if (safeSearch != SafetyLevel.None) dictionary.Add("safe_search", safeSearch.ToString("d"));
if (minUploadDate != null) dictionary.Add("min_upload_date", minUploadDate.Value.ToUnixTimestamp());
if (maxUploadDate != null) dictionary.Add("max_upload_date", maxUploadDate.Value.ToUnixTimestamp());
if (minTakenDate != null) dictionary.Add("min_taken_date", minTakenDate.Value.ToMySql());
if (maxTakenDate != null) dictionary.Add("max_taken_date", maxTakenDate.Value.ToMySql());
if (contentType != ContentTypeSearch.None) dictionary.Add("content_type", contentType.ToString("d"));
if (privacyFilter != PrivacyFilter.None) dictionary.Add("privacy_filter", privacyFilter.ToString("d"));
if (extras != PhotoSearchExtras.None) dictionary.Add("extras", UtilityMethods.ExtrasToString(extras));
if (page != 0) dictionary.Add("page", page.ToString(CultureInfo.InvariantCulture));
if (perPage != 0) dictionary.Add("per_page", perPage.ToString(CultureInfo.InvariantCulture));
return GetResponse<PhotoCollection>(dictionary);
}
public string UploadPicture(Stream stream, string filename, string title, string description, string tags, bool isPublic, bool isFamily, bool isFriend, ContentType contentType, SafetyLevel safetyLevel, HiddenFromSearch hiddenFromSearch)
{
var parameters = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(title))
{
parameters.Add("title", title);
}
if (!string.IsNullOrEmpty(description))
{
parameters.Add("description", description);
}
if (!string.IsNullOrEmpty(tags))
{
parameters.Add("tags", tags);
}
parameters.Add("is_public", isPublic ? "1" : "0");
parameters.Add("is_friend", isFriend ? "1" : "0");
parameters.Add("is_family", isFamily ? "1" : "0");
if (safetyLevel != SafetyLevel.None)
{
parameters.Add("safety_level", safetyLevel.ToString("D"));
}
if (contentType != ContentType.None)
{
parameters.Add("content_type", contentType.ToString("D"));
}
if (hiddenFromSearch != HiddenFromSearch.None)
{
parameters.Add("hidden", hiddenFromSearch.ToString("D"));
}
FlickrResponder.OAuthGetBasicParameters(parameters);
parameters.Add("oauth_consumer_key", ApiKey);
parameters.Add("oauth_token", OAuthAccessToken);
parameters.Add("oauth_signature",
OAuthCalculateSignature("POST", UploadUrl, parameters, OAuthAccessTokenSecret));
var boundary = FlickrResponder.CreateBoundary();
var data = FlickrResponder.CreateUploadData(stream, filename, parameters, boundary);
var oauthHeader = FlickrResponder.OAuthCalculateAuthHeader(parameters);
var contentTypeHeader = "multipart/form-data; boundary=" + boundary;
var response = FlickrResponder.UploadData(UploadUrl, data, contentTypeHeader, oauthHeader);
var match = Regex.Match(response, "<photoid>(\\d+)</photoid>");
if (match.Success)
{
return(match.Groups[1].Value);
}
using (var reader = XmlReader.Create(new StringReader(response), new XmlReaderSettings {
IgnoreWhitespace = true
}))
{
if (!reader.ReadToDescendant("rsp"))
{
throw new XmlException("Unable to find response element 'rsp' in Flickr response");
}
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "stat" && reader.Value == "fail")
{
throw ExceptionHandler.CreateResponseException(reader);
}
}
}
throw new FlickrException("Unable to determine photo id from upload response: " + response);
}
public PhotoCollection PeopleGetPublicPhotos(string userId, SafetyLevel safetyLevel, PhotoSearchExtras extras)
{
return PeopleGetPublicPhotos(userId, 0, 0, safetyLevel, extras);
}
/// <summary>
/// UploadPicture method that does all the uploading work.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> object containing the pphoto to be uploaded.</param>
/// <param name="fileName">The filename of the file to upload. Used as the title if title is null.</param>
/// <param name="title">The title of the photo (optional).</param>
/// <param name="description">The description of the photograph (optional).</param>
/// <param name="tags">The tags for the photograph (optional).</param>
/// <param name="isPublic">false for private, true for public.</param>
/// <param name="isFamily">true if visible to family.</param>
/// <param name="isFriend">true if visible to friends only.</param>
/// <param name="contentType">The content type of the photo, i.e. Photo, Screenshot or Other.</param>
/// <param name="safetyLevel">The safety level of the photo, i.e. Safe, Moderate or Restricted.</param>
/// <param name="hiddenFromSearch">Is the photo hidden from public searches.</param>
/// <returns>The id of the photograph after successful uploading.</returns>
public string UploadPicture(Stream stream, string fileName, string title, string description, string tags,
bool isPublic, bool isFamily, bool isFriend, ContentType contentType,
SafetyLevel safetyLevel, HiddenFromSearch hiddenFromSearch)
{
CheckRequiresAuthentication();
var uploadUri = new Uri(UploadUrl);
var parameters = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(title))
{
parameters.Add("title", title);
}
if (!string.IsNullOrEmpty(description))
{
parameters.Add("description", description);
}
if (!string.IsNullOrEmpty(tags))
{
parameters.Add("tags", tags);
}
parameters.Add("is_public", isPublic ? "1" : "0");
parameters.Add("is_friend", isFriend ? "1" : "0");
parameters.Add("is_family", isFamily ? "1" : "0");
if (safetyLevel != SafetyLevel.None)
{
parameters.Add("safety_level", safetyLevel.ToString("D"));
}
if (contentType != ContentType.None)
{
parameters.Add("content_type", contentType.ToString("D"));
}
if (hiddenFromSearch != HiddenFromSearch.None)
{
parameters.Add("hidden", hiddenFromSearch.ToString("D"));
}
if (!String.IsNullOrEmpty(OAuthAccessToken))
{
OAuthGetBasicParameters(parameters);
parameters.Add("oauth_token", OAuthAccessToken);
string sig = OAuthCalculateSignature("POST", uploadUri.AbsoluteUri, parameters, OAuthAccessTokenSecret);
parameters.Add("oauth_signature", sig);
}
else
{
parameters.Add("api_key", apiKey);
parameters.Add("auth_token", apiToken);
}
string responseXml = UploadData(stream, fileName, uploadUri, parameters);
var settings = new XmlReaderSettings {
IgnoreWhitespace = true
};
var reader = XmlReader.Create(new StringReader(responseXml), settings);
if (!reader.ReadToDescendant("rsp"))
{
throw new XmlException("Unable to find response element 'rsp' in Flickr response");
}
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "stat" && reader.Value == "fail")
{
throw ExceptionHandler.CreateResponseException(reader);
}
}
reader.MoveToElement();
reader.Read();
var t = new UnknownResponse();
((IFlickrParsable)t).Load(reader);
return(t.GetElementValue("photoid"));
}
public void PhotosSetSafetyLevel(string photoId, SafetyLevel safetyLevel, HiddenFromSearch hidden)
{
var dictionary = new Dictionary<string, string>();
dictionary.Add("method", "flickr.photos.setSafetyLevel");
dictionary.Add("photo_id", photoId);
if (safetyLevel != SafetyLevel.None) dictionary.Add("safety_level", safetyLevel.ToString("d"));
if (hidden != HiddenFromSearch.None) dictionary.Add("hidden", hidden.ToString().ToLower());
GetResponse<NoResponse>(dictionary);
}
/// <summary>
/// Set the safety level for a photo.
/// </summary>
/// <param name="photoId">The ID of the photo to set the safety level property for.</param>
/// <param name="safetyLevel">The new value of the safety level value.</param>
public void PhotosSetSafetyLevel(string photoId, SafetyLevel safetyLevel)
{
PhotosSetSafetyLevel(photoId, safetyLevel, HiddenFromSearch.None);
}
/// <summary>
/// Return photos from the given user's photostream. Only photos visible to the calling user will be returned. This method must be authenticated;
/// </summary>
/// <param name="userId">The NSID of the user who's photos to return. A value of "me" will return the calling user's photos.</param>
/// <param name="safeSearch">Safe search setting</param>
/// <param name="minUploadDate">Minimum upload date. Photos with an upload date greater than or equal to this value will be returned.</param>
/// <param name="maxUploadDate">Maximum upload date. Photos with an upload date less than or equal to this value will be returned.</param>
/// <param name="minTakenDate">Minimum taken date. Photos with an taken date greater than or equal to this value will be returned. </param>
/// <param name="maxTakenDate">Maximum taken date. Photos with an taken date less than or equal to this value will be returned. </param>
/// <param name="contentType">Content Type setting</param>
/// <param name="privacyFilter">Return photos only matching a certain privacy level.</param>
/// <param name="extras">A list of extra information to fetch for each returned record.</param>
/// <param name="page">The page of results to return. If this argument is omitted, it defaults to 1.</param>
/// <param name="perPage">Number of photos to return per page. If this argument is omitted, it defaults to 100. The maximum allowed value is 500.</param>
/// <param name="callback">Callback method to call upon return of the response from Flickr.</param>
public void PeopleGetPhotosAsync(string userId, SafetyLevel safeSearch, DateTime minUploadDate, DateTime maxUploadDate, DateTime minTakenDate, DateTime maxTakenDate, ContentTypeSearch contentType, PrivacyFilter privacyFilter, PhotoSearchExtras extras, int page, int perPage, Action<FlickrResult<PhotoCollection>> callback)
{
CheckRequiresAuthentication();
Dictionary<string, string> parameters = new Dictionary<string, string>();
parameters.Add("method", "flickr.people.getPhotos");
parameters.Add("user_id", userId ?? "me");
if (safeSearch != SafetyLevel.None) parameters.Add("safe_search", safeSearch.ToString("d"));
if (minUploadDate != DateTime.MinValue) parameters.Add("min_upload_date", UtilityMethods.DateToUnixTimestamp(minUploadDate));
if (maxUploadDate != DateTime.MinValue) parameters.Add("max_upload_date", UtilityMethods.DateToUnixTimestamp(maxUploadDate));
if (minTakenDate != DateTime.MinValue) parameters.Add("min_taken_date", UtilityMethods.DateToMySql(minTakenDate));
if (maxTakenDate != DateTime.MinValue) parameters.Add("max_taken_date", UtilityMethods.DateToMySql(maxTakenDate));
if (contentType != ContentTypeSearch.None) parameters.Add("content_type", contentType.ToString("d"));
if (privacyFilter != PrivacyFilter.None) parameters.Add("privacy_filter", privacyFilter.ToString("d"));
if (extras != PhotoSearchExtras.None) parameters.Add("extras", UtilityMethods.ExtrasToString(extras));
if (page > 0) parameters.Add("page", page.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
if (perPage > 0) parameters.Add("per_page", perPage.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
GetResponseAsync<PhotoCollection>(parameters, callback);
}
/// <summary>
/// Gets a users public photos. Excludes private photos.
/// </summary>
/// <param name="userId">The user id of the user.</param>
/// <param name="page">The page to return. Defaults to page 1.</param>
/// <param name="perPage">The number of photos to return per page. Default is 100.</param>
/// <param name="extras">Which (if any) extra information to return. The default is none.</param>
/// <param name="safetyLevel">The safety level of the returned photos.
/// Unauthenticated calls can only return Safe photos.</param>
/// <param name="callback">Callback method to call upon return of the response from Flickr.</param>
public async Task <FlickrResult <PhotoCollection> > PeopleGetPublicPhotosAsync(string userId, int page, int perPage, SafetyLevel safetyLevel, PhotoSearchExtras extras)
{
if (!IsAuthenticated && safetyLevel > SafetyLevel.Safe)
{
throw new ArgumentException("Safety level may only be 'Safe' for unauthenticated calls", "safetyLevel");
}
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters.Add("method", "flickr.people.getPublicPhotos");
parameters.Add("api_key", apiKey);
parameters.Add("user_id", userId);
if (perPage > 0)
{
parameters.Add("per_page", perPage.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (page > 0)
{
parameters.Add("page", page.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (safetyLevel != SafetyLevel.None)
{
parameters.Add("safety_level", safetyLevel.ToString("D"));
}
if (extras != PhotoSearchExtras.None)
{
parameters.Add("extras", UtilityMethods.ExtrasToString(extras));
}
return(await GetResponseAsync <PhotoCollection>(parameters));
}
/// <summary>
/// Set the safety level for a photo.
/// </summary>
/// <param name="photoId">The ID of the photo to set the safety level property for.</param>
/// <param name="safetyLevel">The new value of the safety level value.</param>
/// <param name="callback">Callback method to call upon return of the response from Flickr.</param>
public void PhotosSetSafetyLevelAsync(string photoId, SafetyLevel safetyLevel, Action<FlickrResult<NoResponse>> callback)
{
PhotosSetSafetyLevelAsync(photoId, safetyLevel, HiddenFromSearch.None, callback);
}
/// <summary>
/// UploadPicture method that does all the uploading work.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> object containing the pphoto to be uploaded.</param>
/// <param name="title">The title of the photo (optional).</param>
/// <param name="description">The description of the photograph (optional).</param>
/// <param name="tags">The tags for the photograph (optional).</param>
/// <param name="isPublic">0 for private, 1 for public.</param>
/// <param name="isFamily">1 if family, 0 is not.</param>
/// <param name="isFriend">1 if friend, 0 if not.</param>
/// <param name="contentType">The content type of the photo, i.e. Photo, Screenshot or Other.</param>
/// <param name="safetyLevel">The safety level of the photo, i.e. Safe, Moderate or Restricted.</param>
/// <param name="hiddenFromSearch">Is the photo hidden from public searches.</param>
/// <returns>The id of the photograph after successful uploading.</returns>
public string UploadPicture(Stream stream, string title, string description, string tags, int isPublic, int isFamily, int isFriend, ContentType contentType, SafetyLevel safetyLevel, HiddenFromSearch hiddenFromSearch)
{
/*
*
* Modified UploadPicture code taken from the Flickr.Net library
* URL: http://workspaces.gotdotnet.com/flickrdotnet
* It is used under the terms of the Common Public License 1.0
* URL: http://www.opensource.org/licenses/cpl.php
*
* */
string boundary = "FLICKR_MIME_" + DateTime.Now.ToString("yyyyMMddhhmmss");
HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(UploadUrl);
req.UserAgent = "Mozilla/4.0 FlickrNet API (compatible; MSIE 6.0; Windows NT 5.1)";
req.Method = "POST";
if( Proxy != null ) req.Proxy = Proxy;
//req.Referer = "http://www.flickr.com";
req.KeepAlive = true;
req.Timeout = HttpTimeout * 1000;
req.ContentType = "multipart/form-data; boundary=" + boundary + "";
req.Expect = "";
StringBuilder sb = new StringBuilder();
Hashtable parameters = new Hashtable();
if( title != null && title.Length > 0 )
{
parameters.Add("title", title);
}
if( description != null && description.Length > 0 )
{
parameters.Add("description", description);
}
if( tags != null && tags.Length > 0 )
{
parameters.Add("tags", tags);
}
if( isPublic >= 0 )
{
parameters.Add("is_public", isPublic.ToString());
}
if( isFriend >= 0 )
{
parameters.Add("is_friend", isFriend.ToString());
}
if( isFamily >= 0 )
{
parameters.Add("is_family", isFamily.ToString());
}
if( safetyLevel != SafetyLevel.None )
{
parameters.Add("safety_level", (int)safetyLevel);
}
if( contentType != ContentType.None )
{
parameters.Add("content_type", (int)contentType);
}
if( hiddenFromSearch != HiddenFromSearch.None )
{
parameters.Add("hidden", (int)hiddenFromSearch);
}
parameters.Add("api_key", _apiKey);
parameters.Add("auth_token", _apiToken);
string[] keys = new string[parameters.Keys.Count];
parameters.Keys.CopyTo(keys, 0);
Array.Sort(keys);
StringBuilder HashStringBuilder = new StringBuilder(_sharedSecret, 2 * 1024);
foreach(string key in keys)
{
HashStringBuilder.Append(key);
HashStringBuilder.Append(parameters[key]);
sb.Append("--" + boundary + "\r\n");
sb.Append("Content-Disposition: form-data; name=\"" + key + "\"\r\n");
sb.Append("\r\n");
sb.Append(parameters[key] + "\r\n");
}
sb.Append("--" + boundary + "\r\n");
sb.Append("Content-Disposition: form-data; name=\"api_sig\"\r\n");
sb.Append("\r\n");
sb.Append(Md5Hash(HashStringBuilder.ToString()) + "\r\n");
// Photo
sb.Append("--" + boundary + "\r\n");
sb.Append("Content-Disposition: form-data; name=\"photo\"; filename=\"image.jpeg\"\r\n");
sb.Append("Content-Type: image/jpeg\r\n");
sb.Append("\r\n");
UTF8Encoding encoding = new UTF8Encoding();
byte[] postContents = encoding.GetBytes(sb.ToString());
byte[] photoContents = new byte[stream.Length];
stream.Read(photoContents, 0, photoContents.Length);
stream.Close();
byte[] postFooter = encoding.GetBytes("\r\n--" + boundary + "--\r\n");
byte[] dataBuffer = new byte[postContents.Length + photoContents.Length + postFooter.Length];
Buffer.BlockCopy(postContents, 0, dataBuffer, 0, postContents.Length);
Buffer.BlockCopy(photoContents, 0, dataBuffer, postContents.Length, photoContents.Length);
Buffer.BlockCopy(postFooter, 0, dataBuffer, postContents.Length + photoContents.Length, postFooter.Length);
req.ContentLength = dataBuffer.Length;
Stream resStream = req.GetRequestStream();
int j = 1;
int uploadBit = Math.Max(dataBuffer.Length / 100, 50*1024);
int uploadSoFar = 0;
for(int i = 0; i < dataBuffer.Length; i=i+uploadBit)
{
int toUpload = Math.Min(uploadBit, dataBuffer.Length - i);
uploadSoFar += toUpload;
resStream.Write(dataBuffer, i, toUpload);
if( (OnUploadProgress != null) && ((j++) % 5 == 0 || uploadSoFar == dataBuffer.Length) )
{
OnUploadProgress(this, new UploadProgressEventArgs(i+toUpload, uploadSoFar == dataBuffer.Length));
}
}
resStream.Close();
HttpWebResponse res = (HttpWebResponse)req.GetResponse();
XmlSerializer serializer = _uploaderSerializer;
StreamReader sr = new StreamReader(res.GetResponseStream());
string s= sr.ReadToEnd();
sr.Close();
StringReader str = new StringReader(s);
FlickrNet.Uploader uploader = (FlickrNet.Uploader)serializer.Deserialize(str);
if( uploader.Status == ResponseStatus.OK )
{
return uploader.PhotoId;
}
else
{
throw new FlickrApiException(uploader.Error);
}
}
/// <summary>
/// UploadPicture method that does all the uploading work.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> object containing the pphoto to be uploaded.</param>
/// <param name="fileName">The filename of the file to upload. Used as the title if title is null.</param>
/// <param name="title">The title of the photo (optional).</param>
/// <param name="description">The description of the photograph (optional).</param>
/// <param name="tags">The tags for the photograph (optional).</param>
/// <param name="isPublic">false for private, true for public.</param>
/// <param name="isFamily">true if visible to family.</param>
/// <param name="isFriend">true if visible to friends only.</param>
/// <param name="contentType">The content type of the photo, i.e. Photo, Screenshot or Other.</param>
/// <param name="safetyLevel">The safety level of the photo, i.e. Safe, Moderate or Restricted.</param>
/// <param name="hiddenFromSearch">Is the photo hidden from public searches.</param>
/// <returns>The id of the photograph after successful uploading.</returns>
public string UploadPicture(Stream stream, string fileName, string title, string description, string tags, bool isPublic, bool isFamily, bool isFriend, ContentType contentType, SafetyLevel safetyLevel, HiddenFromSearch hiddenFromSearch)
{
CheckRequiresAuthentication();
Uri uploadUri = new Uri(UploadUrl);
Dictionary<string, string> parameters = new Dictionary<string, string>();
if (title != null && title.Length > 0)
{
parameters.Add("title", title);
}
if (description != null && description.Length > 0)
{
parameters.Add("description", description);
}
if (tags != null && tags.Length > 0)
{
parameters.Add("tags", tags);
}
parameters.Add("is_public", isPublic ? "1" : "0");
parameters.Add("is_friend", isFriend ? "1" : "0");
parameters.Add("is_family", isFamily ? "1" : "0");
if (safetyLevel != SafetyLevel.None)
{
parameters.Add("safety_level", safetyLevel.ToString("D"));
}
if (contentType != ContentType.None)
{
parameters.Add("content_type", contentType.ToString("D"));
}
if (hiddenFromSearch != HiddenFromSearch.None)
{
parameters.Add("hidden", hiddenFromSearch.ToString("D"));
}
if (!String.IsNullOrEmpty(OAuthAccessToken))
{
OAuthGetBasicParameters(parameters);
parameters.Add("oauth_token", OAuthAccessToken);
string sig = OAuthCalculateSignature("POST", uploadUri.AbsoluteUri, parameters, OAuthAccessTokenSecret);
parameters.Add("oauth_signature", sig);
}
else
{
parameters.Add("api_key", apiKey);
parameters.Add("auth_token", apiToken);
}
string responseXml = UploadData(stream, fileName, uploadUri, parameters);
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
XmlReader reader = XmlReader.Create(new StringReader(responseXml), settings);
if (!reader.ReadToDescendant("rsp"))
{
throw new XmlException("Unable to find response element 'rsp' in Flickr response");
}
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "stat" && reader.Value == "fail")
throw ExceptionHandler.CreateResponseException(reader);
continue;
}
reader.MoveToElement();
reader.Read();
UnknownResponse t = new UnknownResponse();
((IFlickrParsable)t).Load(reader);
return t.GetElementValue("photoid");
}
/// <summary>
/// UploadPicture method that does all the uploading work.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> object containing the pphoto to be uploaded.</param>
/// <param name="fileName">The filename of the file to upload. Used as the title if title is null.</param>
/// <param name="title">The title of the photo (optional).</param>
/// <param name="description">The description of the photograph (optional).</param>
/// <param name="tags">The tags for the photograph (optional).</param>
/// <param name="isPublic">false for private, true for public.</param>
/// <param name="isFamily">true if visible to family.</param>
/// <param name="isFriend">true if visible to friends only.</param>
/// <param name="contentType">The content type of the photo, i.e. Photo, Screenshot or Other.</param>
/// <param name="safetyLevel">The safety level of the photo, i.e. Safe, Moderate or Restricted.</param>
/// <param name="hiddenFromSearch">Is the photo hidden from public searches.</param>
/// <returns>The id of the photograph after successful uploading.</returns>
async public Task <string> UploadPicture(string fullPath, IProgress <UploadProgressChangedEventArgs> progress, string title = "", string description = "", string tags = "", bool isPublic = false, bool isFamily = true, bool isFriend = false, ContentType contentType = ContentType.None, SafetyLevel safetyLevel = SafetyLevel.Restricted, HiddenFromSearch hiddenFromSearch = HiddenFromSearch.Hidden)
{
CheckRequiresAuthentication();
string fileName = Path.GetFileName(fullPath);
using (Stream stream = new FileStream(fullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
Uri uploadUri = new Uri(UploadUrl);
Dictionary <string, string> parameters = new Dictionary <string, string>();
if (string.IsNullOrEmpty(title))
{
}
else
{
parameters.Add("title", title);
}
if (string.IsNullOrEmpty(description))
{
}
else
{
parameters.Add("description", description);
}
if (string.IsNullOrEmpty(tags))
{
}
else
{
parameters.Add("tags", tags);
}
parameters.Add("is_public", isPublic ? "1" : "0");
parameters.Add("is_friend", isFriend ? "1" : "0");
parameters.Add("is_family", isFamily ? "1" : "0");
if (safetyLevel != SafetyLevel.None)
{
parameters.Add("safety_level", safetyLevel.ToString("D"));
}
if (contentType != ContentType.None)
{
parameters.Add("content_type", contentType.ToString("D"));
}
if (hiddenFromSearch != HiddenFromSearch.None)
{
parameters.Add("hidden", hiddenFromSearch.ToString("D"));
}
OAuthGetBasicParameters(parameters);
string sig = OAuthCalculateSignature("POST", uploadUri.AbsoluteUri, parameters, OAuthAccessTokenSecret);
parameters.Add("oauth_signature", sig);
//string responseXml = UploadData(stream, fileName, uploadUri, parameters);
string responseXml = await UploadData(stream, fullPath, uploadUri, parameters, progress);
var r = "";
if (string.IsNullOrEmpty(responseXml))
{
}
else
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
XmlReader reader = XmlReader.Create(new StringReader(responseXml), settings);
if (!reader.ReadToDescendant("rsp"))
{
throw new XmlException("Unable to find response element 'rsp' in Flickr response");
}
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "stat" && reader.Value == "fail")
{
throw new Exception();
}
//TODO:
//throw ExceptionHandler.CreateResponseException(reader);
continue;
}
reader.MoveToElement();
reader.Read();
UnknownResponse t = new UnknownResponse();
((IFlickrParsable)t).Load(reader);
stream.Close();
r = t.GetElementValue("photoid");
}
return(r);
}
}
