/// <summary>
/// Liefert eine Liste von Kunden zu einem Matchcode Filter
/// </summary>
/// <param name="mandant"></param>
/// <param name="filter"></param>
/// <returns></returns>
public static List <Kunde> GetKunden(Mandant mandant, string filter)
{
var kunden = new List <Kunde>();
var parameterList = new QueryParameterList();
parameterList.AddClauseParameter("Mandant", mandant.Id);
if (!filter.StartsWith("%"))
{
filter = "%" + filter;
}
if (!filter.EndsWith("%"))
{
filter = filter + "%";
}
parameterList.AddClauseParameter("Matchcode", filter, ClauseParameterComparisonType.Like);
parameterList.AddClauseParameter("KtoArt", "D");
var kontokorrentSet = mandant.MainDevice.Entities.Kontokorrent.GetList(parameterList);
foreach (var k in kontokorrentSet)
{
kunden.Add(SeminarData.GetKunde(mandant, k.Kto));
}
return(kunden);
}
private MediaItem UploadMediaItemToAlbum(MediaItem mediaItem, string albumPath)
{
string relativeUploadUrl = GenerateRelativeUploadUrl( albumPath );
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add( new QueryParameter( _format, "xml" ) );
paramaters.Add( new QueryParameter( _type, mediaItem.Type ) );
if (string.IsNullOrEmpty( mediaItem.Description ) == false)
{
paramaters.Add( new QueryParameter( _description, OAuth.UrlEncode(mediaItem.Description) ) );
}
if (string.IsNullOrEmpty( mediaItem.Title ) == false)
{
paramaters.Add( new QueryParameter( _title, OAuth.UrlEncode(mediaItem.Title) ) );
}
QueryParameterList mediaParamaters = OAuth.GenerateOAuthParamaters( relativeUploadUrl, _uploadMediaMethod, Token, paramaters );
string uploadMediaItemUrl = ApiUrl + relativeUploadUrl + "?format=xml";
XmlResponseMessage uploadMediaItemResponse = GetResponseForUploadMediaItem( uploadMediaItemUrl, mediaItem, mediaParamaters );
MediaItem newMediaItem = new MediaItem( uploadMediaItemResponse.ResponseXml );
_currentUser.MediaList.Add(newMediaItem);
return newMediaItem;
}
public MediaItemList GetFeaturedMedia()
{
string relativePath = GenerateRelativeFeaturedUrl();
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
string getFeaturedMediaUrl = OAuth.GenerateURL(_apiUrl, relativePath, _featuredMediaMethod, Token, paramaters);
XmlResponseMessage getFeaturedMediaResponseMessage = GetXmlResponseMessageFromUrl(getFeaturedMediaUrl, _featuredMediaMethod);
return MediaItemList.CreateFromXmlResponseMessage(getFeaturedMediaResponseMessage);
}
/// <summary>
/// Get the User object that represents the user currently logged on
/// </summary>
/// <returns></returns>
private User GetUser(string username)
{
string relativePath = GenerateRelativeUserUrl( username );
QueryParameterList paramaters = new QueryParameterList( );
paramaters.Add( new QueryParameter( _format, "xml" ) );
string getUserUrl = OAuth.GenerateURL(ApiUrl, relativePath, _getUserMethod, Token, paramaters);
XmlResponseMessage getUserResponseMessage = GetXmlResponseMessageFromUrl( getUserUrl, _getUserMethod );
return new User(getUserResponseMessage.ResponseXml);
}
public void DeleteMediaDescription(ref MediaItem mediaItem)
{
string relativePath = GenerateRelativeMediaDescriptionUrl(mediaItem.Url);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
string deleteMediaDescriptionUrl = OAuth.GenerateURL(ApiUrl, relativePath, _deleteMediaDescriptionMethod, Token, paramaters);
XmlResponseMessage deleteMediaDescriptionResponseMessage = GetXmlResponseMessageFromUrl(deleteMediaDescriptionUrl, _deleteMediaDescriptionMethod);
mediaItem.Description = String.Empty;
}
/// <summary>
/// Aktualisiert bzw. legt einen neuen Ansprechpartner an
/// </summary>
/// <param name="mandant"></param>
/// <param name="ansprechpartner"></param>
/// <returns></returns>
public static AnsprechpartnerItem UpdateAnsprechpartner(Mandant mandant, AnsprechpartnerItem ansprechpartner)
{
AnsprechpartnerItem item = null;
if (SeminarData.AnsprechpartnerExists(mandant, ansprechpartner.Adresse, ansprechpartner.EMail))
{
var parameterList = new QueryParameterList();
parameterList.AddClauseParameter("Mandant", mandant.Id);
parameterList.AddClauseParameter("Adresse", ansprechpartner.Adresse);
parameterList.AddClauseParameter("EMail", ansprechpartner.EMail);
item = mandant.MainDevice.Entities.Ansprechpartner.GetItem(parameterList);
}
else
{
item = mandant.MainDevice.Entities.Ansprechpartner.CreateItem();
item.Mandant = mandant.Id;
}
item.Abteilung = ansprechpartner.Abteilung;
item.Adresse = ansprechpartner.Adresse;
item.Anrede = ansprechpartner.Anrede;
item.Ansprechpartner = ansprechpartner.Ansprechpartner;
item.Autotelefon = ansprechpartner.Autotelefon;
item.Briefanrede = ansprechpartner.Briefanrede;
item.EMail = ansprechpartner.EMail;
if (ansprechpartner.Geburtsdatum.HasValue)
{
item.Geburtsdatum = ansprechpartner.Geburtsdatum.GetValueOrDefault();
}
item.Gruppe = ansprechpartner.Gruppe;
item.Memo = ansprechpartner.Memo;
item.Mobilfunk = ansprechpartner.Mobilfunk;
item.Nachname = ansprechpartner.Nachname;
item.Position = ansprechpartner.Position;
item.Telefax = ansprechpartner.Telefax;
item.Telefon = ansprechpartner.Telefon;
item.TelefonPrivat = ansprechpartner.TelefonPrivat;
item.Titel = ansprechpartner.Titel;
item.Transferadresse = ansprechpartner.Transferadresse;
item.Vorname = ansprechpartner.Vorname;
item.ZuHaendenText = ansprechpartner.ZuHaendenText;
//ansprechpartner.UserDefinedFields.ToList().ForEach(u => item.UserDefinedFields[u.Name].Value = u.Value);
var result = item.TrySave();
if (!result.IsSucceeded)
{
TraceLog.LogException(result.ExceptionOccurred);
throw result.ExceptionOccurred;
}
return(item);
}
public MediaItemList GetFeaturedMedia()
{
string relativePath = GenerateRelativeFeaturedUrl();
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
string getFeaturedMediaUrl = OAuth.GenerateURL(_apiUrl, relativePath, _featuredMediaMethod, Token, paramaters);
XmlResponseMessage getFeaturedMediaResponseMessage = GetXmlResponseMessageFromUrl(getFeaturedMediaUrl, _featuredMediaMethod);
return(MediaItemList.CreateFromXmlResponseMessage(getFeaturedMediaResponseMessage));
}
private Album CreateNewAlbum(string albumName, string albumPath)
{
string relativePath = GenerateRelativeAlbumUrl(albumPath);
QueryParameterList paramaters = new QueryParameterList( );
paramaters.Add( new QueryParameter( _name, albumName ) );
paramaters.Add( new QueryParameter( _format, "xml" ) );
string createNewAlbumUrl = OAuth.GenerateURL(ApiUrl, relativePath, _createAlbumMethod, Token, paramaters);
XmlResponseMessage createNewAlbumResponseMessage = GetXmlResponseMessageFromUrl(createNewAlbumUrl, _createAlbumMethod);
return new Album(albumName, albumPath);
}
public MediaItem GetMediaInformation(ref MediaItem mediaItem)
{
string relativePath = GenerateRelativeMediaInformationUrl(mediaItem.Url);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
string getMediaInformationUrl = OAuth.GenerateURL(ApiUrl, relativePath, _getMediaInformationMethod, Token, paramaters);
XmlResponseMessage getMediaInformationResponseMessage = GetXmlResponseMessageFromUrl(getMediaInformationUrl, _getMediaInformationMethod);
mediaItem = MediaItem.CreateFromXmlNode(mediaItem.MediaType, getMediaInformationResponseMessage.ResponseXml.SelectSingleNode("descendant::media"));
return mediaItem;
}
public string GetMediaDescription(ref MediaItem mediaItem)
{
string relativePath = GenerateRelativeMediaDescriptionUrl(mediaItem.Url);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
string getMediaDescriptionUrl = OAuth.GenerateURL(ApiUrl, relativePath, _getMediaDescriptionMethod, Token, paramaters);
XmlResponseMessage getMediaDescriptionResponseMessage = GetXmlResponseMessageFromUrl(getMediaDescriptionUrl, _getMediaDescriptionMethod);
XmlNode descriptionNode = getMediaDescriptionResponseMessage.ResponseXml.SelectSingleNode("descendant::description");
mediaItem.Description = descriptionNode.InnerText;
return mediaItem.Description;
}
public MediaItemList GetUsersRecentMedia(string username, MediaType type, int page, int perPage)
{
string relativePath = GenerateRelativeUserSearchUrl(username);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
paramaters.Add(new QueryParameter(_type, type.ToString().ToLower()));
paramaters.Add(new QueryParameter(_page, page.ToString()));
paramaters.Add(new QueryParameter(_perpage, perPage.ToString()));
string getUsersRecentMediaUrl = OAuth.GenerateURL(ApiUrl, relativePath, _getUserMediaMethod, Token, paramaters);
XmlResponseMessage getUsersRecentMediaResponseMessage = GetXmlResponseMessageFromUrl(getUsersRecentMediaUrl, _getUserMediaMethod);
return MediaItemList.CreateFromXmlResponseMessage(getUsersRecentMediaResponseMessage);
}
/// <summary>
/// 调用一个Oauth API, 自动处理签名逻辑。参数放在Body。
/// </summary>
/// <param name="oauthInfo">OAuth认证信息</param>
/// <param name="parameters">业务相关参数（除OAuth认证信息中的其它参数）</param>
/// <param name="contentType">请求内容类型</param>
/// <returns></returns>
public static WebResponse CallOAuthApi(this OAuthInfomation oauthInfo, QueryParameterList parameters, string contentType = "application/x-www-form-urlencoded")
{
var oauth = new OAuthSignatureGenerator();
var result = oauth.GenerateSignature(oauthInfo, parameters);
var postData = Encoding.UTF8.GetBytes(parameters.ToString());
var request = WebRequest.Create(oauthInfo.RequestUri);
request.Method = oauthInfo.HttpMethod;
request.ContentLength = postData.Length;
request.ContentType = contentType;
request.Headers["Authorization"] = oauthInfo.GenerateAuthorizationHeader(result.Signature);
using (var responseStream = request.GetRequestStream())
{
responseStream.Write(postData, 0, postData.Length);
}
return(request.GetResponse());
}
private Album GetAlbum(string albumPath, bool recurse, string view, string media, bool paginated, int page, int perpage)
{
string relativePath = GenerateRelativeAlbumUrl(albumPath);
QueryParameterList paramaters = new QueryParameterList( );
paramaters.Add( new QueryParameter( _format, "xml" ) );
paramaters.Add(new QueryParameter(_recurse, recurse ? "1" : "0"));
paramaters.Add(new QueryParameter(_view, view));
paramaters.Add(new QueryParameter(_media, media));
paramaters.Add(new QueryParameter(_paginated, paginated ? "1" : "0"));
paramaters.Add(new QueryParameter(_page, page.ToString()));
paramaters.Add(new QueryParameter(_perpage, perpage.ToString()));
string getUsersAlbumUrl = OAuth.GenerateURL(ApiUrl, relativePath, _getAlbumMethod, Token, paramaters);
XmlResponseMessage getUsersAlbumResponseMessage = GetXmlResponseMessageFromUrl(getUsersAlbumUrl, _getAlbumMethod);
return new Album(getUsersAlbumResponseMessage.ResponseXml.SelectSingleNode("descendant::album"));
}
public MediaItemList SearchMedia(string query, int num, int perpage, int page, int offset, int secondaryperpage, string type, bool recentFirst)
{
string relativePath = GenerateRelativeSearchUrl(query);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
paramaters.Add(new QueryParameter(_num, num.ToString()));
paramaters.Add(new QueryParameter(_perpage, perpage.ToString()));
paramaters.Add(new QueryParameter(_page, page.ToString()));
paramaters.Add(new QueryParameter(_offset, offset.ToString()));
paramaters.Add(new QueryParameter(_secondaryperpage, secondaryperpage.ToString()));
paramaters.Add(new QueryParameter(_type, type));
paramaters.Add(new QueryParameter(_recentfirst, recentFirst ? "1" : "0" ));
string searchMediaUrl = OAuth.GenerateURL(_apiUrl, relativePath, _searchMediaMethod, Token, paramaters);
XmlResponseMessage searchMediaResponseMessage = GetXmlResponseMessageFromUrl(searchMediaUrl, _searchMediaMethod);
return MediaItemList.CreateFromXmlResponseMessage(searchMediaResponseMessage);
}
/// <summary>
/// Generates a signature using the specified signatureType
/// </summary>
/// <param name="oauth">The information that needs to be signed</param>
/// <param name="extraParameters">The parameters</param>
public SignatureResult GenerateSignature(OAuthInfomation oauth, QueryParameterList extraParameters)
{
SignatureResult result = new SignatureResult();
switch (oauth.SignatureMethod)
{
case SignatureTypes.PLAINTEXT:
result.Signature = HttpUtility.UrlEncode(oauth.GetSignatureKey);
break;
case SignatureTypes.HMACSHA1:
result = GenerateSignatureBase(oauth, extraParameters);
result.Signature = ComputeHash(new HMACSHA1(Encoding.ASCII.GetBytes(oauth.GetSignatureKey)), result.SignatureBase);
break;
case SignatureTypes.RSASHA1:
throw new NotImplementedException();
default:
throw new ArgumentException("Unknown signature type", "signatureType");
}
return result;
}
public MediaItemList SearchMedia(string query, int num, int perpage, int page, int offset, int secondaryperpage, string type, bool recentFirst)
{
string relativePath = GenerateRelativeSearchUrl(query);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
paramaters.Add(new QueryParameter(_num, num.ToString()));
paramaters.Add(new QueryParameter(_perpage, perpage.ToString()));
paramaters.Add(new QueryParameter(_page, page.ToString()));
paramaters.Add(new QueryParameter(_offset, offset.ToString()));
paramaters.Add(new QueryParameter(_secondaryperpage, secondaryperpage.ToString()));
paramaters.Add(new QueryParameter(_type, type));
paramaters.Add(new QueryParameter(_recentfirst, recentFirst ? "1" : "0"));
string searchMediaUrl = OAuth.GenerateURL(_apiUrl, relativePath, _searchMediaMethod, Token, paramaters);
XmlResponseMessage searchMediaResponseMessage = GetXmlResponseMessageFromUrl(searchMediaUrl, _searchMediaMethod);
return(MediaItemList.CreateFromXmlResponseMessage(searchMediaResponseMessage));
}
public bool ValidateUserToken(UserToken userToken)
{
string relativePath = GenerateRelativeUserUrl( userToken.Username );
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add( new QueryParameter( _format, "xml" ) );
string validateUserUrl = OAuth.GenerateURL( userToken.UserApi , relativePath, _getUserMethod, userToken, paramaters );
try
{
XmlResponseMessage getUserResponseMessage = GetXmlResponseMessageFromUrl( validateUserUrl, _getUserMethod );
return true;
}
catch (PhotobucketApiException apiEx)
{
if (apiEx.ErrorCode == ErrorCode.CouldNotGet)
{
return false;
}
throw;
}
}
public bool ValidateUserToken(UserToken userToken)
{
string relativePath = GenerateRelativeUserUrl( userToken.Username );
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add( new QueryParameter( _format, "xml" ) );
string validateUserUrl = OAuth.GenerateURL( userToken.UserApi , relativePath, _getUserMethod, userToken, paramaters );
try
{
XmlResponseMessage getUserResponseMessage = GetXmlResponseMessageFromUrl( validateUserUrl, _getUserMethod );
return true;
}
catch (PhotobucketApiException apiEx)
{
if (apiEx.ErrorCode == ErrorCode.CouldNotGet)
{
return false;
}
throw;
}
}
/// <summary>
/// Internal function to cut out all non oauth query string parameters (all parameters not begining with "oauth_")
/// </summary>
/// <param name="parameters">The query string part of the Url</param>
/// <returns>A list of QueryParameter each containing the parameter name and value</returns>
private QueryParameterList GetQueryParameters(string parameters)
{
if (parameters.StartsWith("?"))
{
parameters = parameters.Remove(0, 1);
}
var result = new QueryParameterList(BodyDataFormat.EncodedUrl);
if (!String.IsNullOrEmpty(parameters))
{
string[] p = parameters.Split('&');
foreach (string s in p)
{
if (!String.IsNullOrEmpty(s) && !s.StartsWith(OAuthParameterPrefix))
{
if (s.IndexOf('=') > -1)
{
string[] temp = s.Split('=');
result.Add(new QueryParameter(temp[0], temp[1]));
}
else
{
result.Add(new QueryParameter(s, String.Empty));
}
}
}
}
return result;
}
/// <summary>
/// Generate the signature base that is used to produce the signature
/// </summary>
/// <param name="oauth">The full url that needs to be signed </param>
/// <param name="extraParameters">The parameters</param>
private SignatureResult GenerateSignatureBase(OAuthInfomation oauth, QueryParameterList extraParameters)
{
if (oauth.Token == null)
{
oauth.Token = String.Empty;
}
if (oauth.TokenSecret == null)
{
oauth.TokenSecret = String.Empty;
}
var result = new SignatureResult();
var parameters = GetQueryParameters(oauth.RequestUri.Query);
parameters.AddRange(oauth.GetParametersForSignature());
parameters.AddRange(extraParameters.Where(p => p.NeedSign));
parameters.Sort(new QueryParameterComparer());
var signatureBase = new StringBuilder();
signatureBase.AppendFormat("{0}&", oauth.HttpMethod.ToUpper());
signatureBase.AppendFormat("{0}&", UrlEncode(oauth.RequestUri.Normalize()));
signatureBase.AppendFormat("{0}", UrlEncode(parameters.ToString()));
result.SignatureBase = signatureBase.ToString();
return result;
}
public void DeleteMediaTag(MediaItem mediaItem, MediaTag tag)
{
string relativePath = GenerateRelativeMediaTagUrl(mediaItem.Url);
relativePath = relativePath + "/" + tag.TagId.ToString();
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
string deleteMediaTagUrl = OAuth.GenerateURL(ApiUrl, relativePath, _deleteMediaTagMethod, Token, paramaters);
XmlResponseMessage deleteMediaTagResponseMessage = GetXmlResponseMessageFromUrl(deleteMediaTagUrl, _deleteMediaTagMethod);
}
private Privacy UpdateAlbumPrivacySettings(string albumPath, Privacy privacySetting, string password)
{
string relativePath = GenerateRelativeAlbumPrivacyUrl(albumPath);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
if (privacySetting == Privacy.PUBLIC)
{
paramaters.Add(new QueryParameter(_privacy, "public"));
}
else
{
paramaters.Add(new QueryParameter(_privacy, "private"));
paramaters.Add(new QueryParameter(_password, password));
}
string updateAlbumPrivacySettingsUrl = OAuth.GenerateURL(ApiUrl, relativePath, _updateAlbumPrivacyMethod, Token, paramaters);
XmlResponseMessage updateAlbumPrivacySettingsResponseMessage = GetXmlResponseMessageFromUrl(updateAlbumPrivacySettingsUrl, _updateAlbumPrivacyMethod);
return GetPrivacyFromResponseMessage(updateAlbumPrivacySettingsResponseMessage);
}
private Privacy GetAlbumsPrivacySettings(string albumPath)
{
string relativePath = GenerateRelativeAlbumPrivacyUrl(albumPath);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
string getAlbumPrivacySettingsUrl = OAuth.GenerateURL(ApiUrl, relativePath, _getAlbumPrivacyMethod, Token, paramaters);
XmlResponseMessage getAlbumPrivacySettingsResponseMessage = GetXmlResponseMessageFromUrl(getAlbumPrivacySettingsUrl, _getAlbumPrivacyMethod);
return GetPrivacyFromResponseMessage(getAlbumPrivacySettingsResponseMessage);
}
public MediaItemList GetRelatedMedia(MediaItem mediaItem, int num, MediaType mediaType)
{
string relativePath = GenerateRelativeRelatedMediaUrl(mediaItem.Url);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
paramaters.Add(new QueryParameter(_num, num.ToString()));
string type = mediaType == MediaType.Image ? "images" : "videos";
paramaters.Add(new QueryParameter(_type, type));
string getRelatedMediaUrl = OAuth.GenerateURL(ApiUrl, relativePath, _getRelatedMediaMethod, Token, paramaters);
XmlResponseMessage getRelatedMediaResponseMessage = GetXmlResponseMessageFromUrl(getRelatedMediaUrl, _getRelatedMediaMethod);
return MediaItemList.CreateFromXmlNodeList(getRelatedMediaResponseMessage.ResponseXml.SelectNodes("descendant::media"));
}
public MediaTag GetMediaTag(MediaItem mediaItem, int tagId)
{
string relativePath = GenerateRelativeMediaTagUrl(mediaItem.Url);
relativePath = relativePath + "/" + tagId.ToString();
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
string getMediaTagUrl = OAuth.GenerateURL(ApiUrl, relativePath, _getMediaTagMethod, Token, paramaters);
XmlResponseMessage getMediaTagResponseMessage = GetXmlResponseMessageFromUrl(getMediaTagUrl, _getMediaTagMethod);
return MediaTag.CreateFromXmlNode(getMediaTagResponseMessage.ResponseXml.SelectSingleNode("descendant::content"));
}
public void RotateImage(MediaItem mediaItem, int degrees)
{
string relativePath = GenerateRelativeRotateImageUrl(mediaItem.Url);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
string rotateImageUrl = OAuth.GenerateURL(ApiUrl, relativePath, _rotateImageMethod, Token, paramaters);
XmlResponseMessage rotateImageResponseMessage = GetXmlResponseMessageFromUrl(rotateImageUrl, _rotateImageMethod);
}
public AlbumList GetAllUsersAlbums(string username)
{
string relativePath = GenerateRelativeAlbumUrl(username);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
paramaters.Add(new QueryParameter(_recurse, "1"));
paramaters.Add(new QueryParameter(_view, "flat"));
paramaters.Add(new QueryParameter(_media, "none"));
string getAllUsersAlbumsUrl = OAuth.GenerateURL(ApiUrl, relativePath, _getAlbumMethod, Token, paramaters);
XmlResponseMessage getAllUsersAlbumsResponseMessage = GetXmlResponseMessageFromUrl(getAllUsersAlbumsUrl, _getAlbumMethod);
return AlbumList.CreateFromXmlResponseMessage(getAllUsersAlbumsResponseMessage);
}
public MetaData GetMediaMetaData(ref MediaItem mediaItem)
{
string relativePath = GenerateRelativeMediaMetaDataUrl(mediaItem.Url);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
string getMediaMetaDataUrl = OAuth.GenerateURL(ApiUrl, relativePath, _getMediaMetaDataMethod, Token, paramaters);
XmlResponseMessage getMediaMetaDataResponseMessage = GetXmlResponseMessageFromUrl(getMediaMetaDataUrl, _getMediaMetaDataMethod);
mediaItem.SetMetaData = MetaData.CreateFromXmlResponseMessage(getMediaMetaDataResponseMessage);
return mediaItem.MetaData;
}
private XmlDocument GetMediaLinks(MediaItem mediaItem)
{
string relativePath = GenerateRelativeMediaLinksUrl( mediaItem.Url );
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add( new QueryParameter( _format, "xml" ) );
string getMediaLinksUrl = OAuth.GenerateURL( ApiUrl, relativePath, _getMediaLinksMethod, Token, paramaters );
XmlResponseMessage getMediaLinksResponseMessage = GetXmlResponseMessageFromUrl( getMediaLinksUrl, _getMediaLinksMethod );
return getMediaLinksResponseMessage.ResponseXml;
}
private XmlResponseMessage GetResponseForUploadMediaItem(string uploadMediaItemUrl, MediaItem mediaItem, QueryParameterList paramaters)
{
string boundary = "PHOTBUCKET_MIME_" + DateTime.Now.ToString( "yyyyMMddhhmmss" );
HttpWebRequest request = ( HttpWebRequest )HttpWebRequest.Create( uploadMediaItemUrl );
request.UserAgent = "Mozilla/4.0 PhotobucketNet API (compatible; MSIE 6.0; Windows NT 5.1)";
request.Method = "POST";
request.KeepAlive = true;
request.ContentType = "multipart/form-data; boundary=" + boundary + "";
request.Expect = "";
StringBuilder sb = new StringBuilder();
foreach (QueryParameter paramater in paramaters)
{
if (paramater.Name == "format")
{
continue;
}
else if (paramater.Name == "oauth_signature")
{
paramater.Value = OAuth.UrlDecode( paramater.Value );
}
else if (paramater.Name == _description || paramater.Name == _title)
{
paramater.Value = OAuth.UrlDecode( paramater.Value );
}
sb.Append( "--" + boundary + "\r\n" );
sb.Append( "Content-Disposition: form-data; name=\"" + paramater.Name + "\"\r\n" );
sb.Append( "\r\n" );
sb.Append( paramater.Value + "\r\n" );
}
sb.Append( "--" + boundary + "\r\n" );
sb.Append( "Content-Disposition: form-data; name=\"uploadfile\"; filename=\"" + mediaItem.Name + "\"\r\n" );
sb.Append( "Content-Type: mimetype\r\nContent-Transfer-Ecoding: binary" );
sb.Append( "\r\n\r\n" );
UTF8Encoding encoding = new UTF8Encoding();
byte[] postContents = encoding.GetBytes( sb.ToString() );
Stream stream = mediaItem.MediaStream;
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 );
request.ContentLength = dataBuffer.Length;
Stream resStream = request.GetRequestStream();
int count = 1;
int uploadBit = Math.Max( dataBuffer.Length / 100, 50 * 1024 );
int uploadSoFar = 0;
if ( OnUploadMediaProgress != null )
{
OnUploadMediaProgress( this, new UploadMediaProgressEventArgs( 0, dataBuffer.Length ) );
}
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 (( OnUploadMediaProgress != null ) && ( ( count++ ) % 5 == 0 || uploadSoFar == dataBuffer.Length ))
{
OnUploadMediaProgress( this, new UploadMediaProgressEventArgs( uploadSoFar, dataBuffer.Length ) );
}
}
resStream.Close();
try
{
request.Method = _uploadMediaMethod;
HttpWebResponse response = ( HttpWebResponse )request.GetResponse();
Stream responseStream = response.GetResponseStream();
return new XmlResponseMessage( responseStream );
}
catch (WebException webEx)
{
throw PhotobucketException.CreateFromWebException( webEx );
}
}
public void UpdateMediaTag(MediaItem mediaItem, MediaTag tag)
{
string relativePath = GenerateRelativeMediaTagUrl(mediaItem.Url);
relativePath = relativePath + "/" + tag.TagId.ToString();
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
if (tag.TopLeftX == -1)
{
paramaters.Add(new QueryParameter("topleftx", tag.TopLeftX.ToString()));
}
if (tag.TopLeftY == -1)
{
paramaters.Add(new QueryParameter("toplefty", tag.TopLeftY.ToString()));
}
if (tag.BottomRightX == -1)
{
paramaters.Add(new QueryParameter("bottomrightx", tag.BottomRightX.ToString()));
}
if (tag.BottomRightY == -1)
{
paramaters.Add(new QueryParameter("bottomrighty", tag.BottomRightY.ToString()));
}
if (string.IsNullOrEmpty(tag.Name) == false)
{
paramaters.Add(new QueryParameter("tag", tag.Name));
}
if (string.IsNullOrEmpty(tag.Contact) == false)
{
paramaters.Add(new QueryParameter("contact", tag.Contact));
}
if (string.IsNullOrEmpty(tag.Url) == false)
{
paramaters.Add(new QueryParameter("tagurl", tag.Url));
}
string updateMediaTagUrl = OAuth.GenerateURL(ApiUrl, relativePath, _updateMediaTagMethod, Token, paramaters);
XmlResponseMessage updateMediaTagResponseMessage = GetXmlResponseMessageFromUrl(updateMediaTagUrl, _updateMediaTagMethod);
}
private void RenameAlbum(string origAlbumPath, string newAlbumName)
{
string relativePath = GenerateRelativeAlbumUrl(origAlbumPath);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_name, newAlbumName));
paramaters.Add(new QueryParameter(_format, "xml"));
string renameAlbumUrl = OAuth.GenerateURL(ApiUrl, relativePath, _renameAlbumMethod, Token, paramaters);
XmlResponseMessage renameAlbumResponseMessage = GetXmlResponseMessageFromUrl(renameAlbumUrl, _renameAlbumMethod);
}
public Query(string text, ParameterStyle style)
{
this.text = text;
this.style = style;
parameters = new QueryParameterList(this);
}
private void DeleteAlbum(string albumPath)
{
string relativePath = GenerateRelativeAlbumUrl(albumPath);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
string deleteAlbumUrl = OAuth.GenerateURL(ApiUrl, relativePath, _deleteAlbumMethod, Token, paramaters);
XmlResponseMessage deleteAlbumResponseMessage = GetXmlResponseMessageFromUrl(deleteAlbumUrl, _deleteAlbumMethod);
}
public void SetMediaTitle(ref MediaItem mediaItem, string title)
{
string relativePath = GenerateRelativeMediaTitleUrl(mediaItem.Url);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
paramaters.Add(new QueryParameter(_title, title));
string setMediaTitleUrl = OAuth.GenerateURL(ApiUrl, relativePath, _setMediaTitleMethod, Token, paramaters);
XmlResponseMessage setMediaTitleResponseMessage = GetXmlResponseMessageFromUrl(setMediaTitleUrl, _setMediaTitleMethod);
mediaItem.Title = title;
}
public void ShareMediaViaEmail(MediaItem mediaItem, string email, string body)
{
string relativePath = GenerateRelativeShareUrl(mediaItem.Url);
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add(new QueryParameter(_format, "xml"));
paramaters.Add(new QueryParameter("body", body));
paramaters.Add(new QueryParameter("email", email));
string shareMediaViaEmailUrl = OAuth.GenerateURL(ApiUrl, relativePath, _shareMediaViaEmailMethod, Token, paramaters);
XmlResponseMessage shareMediaViaEmailResponseMessage = GetXmlResponseMessageFromUrl(shareMediaViaEmailUrl, _shareMediaViaEmailMethod);
}
