public async Task<bool> FileExistsAsync(string gfsname, MediaTypeEnum bucketName)
{
var bucket = new GridFSBucket(_db, new GridFSBucketOptions
{
BucketName = bucketName.ToString()
});
var filter = Builders<GridFSFileInfo>.Filter.Eq(x => x.Filename, gfsname);
var fileInfo = await bucket.FindAsync(filter);
return fileInfo.Any();
}
/// <summary>
/// Updates watchlist boolean.
/// </summary>
private async Task updateWatchlist()
{
// Written, 02.02.2020
this.watch_button.Enabled = false;
this.watch_button.Text = "processing..";
MediaTypeEnum mediaType = this.media is TvSearchResult ? MediaTypeEnum.tv : MediaTypeEnum.movie;
List <IdResultObject> watchedMedia = new List <IdResultObject>();
watchedMedia.AddRange(this.viewAccount.watchlistMovies);
watchedMedia.AddRange(this.viewAccount.watchlistTvSeries);
bool watched = watchedMedia.Any(_fm => _fm.id == this.media.id);
await this.viewAccount.user.watchlistMediaItem(mediaType, media.id, !watched);
switch (mediaType)
{
case MediaTypeEnum.movie:
await this.viewAccount.retrieveWatchlistMoviesAsync();
break;
case MediaTypeEnum.tv:
await this.viewAccount.retrieveWatchlistTvSeriesAsync();
break;
}
this.updateWatchlistDisplay();
this.watch_button.Enabled = true;
this.watchListChanged = true;
}
/**
* detach stream from video window
* @param mediaType: stream mediaType- local, remote, PIP and content
* @return true: successfully detached; false: fail to detach
* */
public static bool DetachStreamFromWindow(MediaTypeEnum mediaType, int streamId, int callHandle)
{
log.Debug("[detachStreamFromWindow] mediatype " + mediaType.ToString() + " from video window.");
if (mediaType != MediaTypeEnum.PLCM_MF_STREAM_LOCAL)
{
if (invalidCallHandle != callHandle)
{
var errNo = WrapperProxy.DetachStreamWnd(mediaType, streamId, callHandle);
if (ErrorNumberEnum.PLCM_SAMPLE_OK != errNo)
{
log.Error("detach stream from window failed. Error number = " + errNo.ToString());
return(false);
}
}
else
{
log.Error("no such call to detach stream window");
return(false);
}
}
else
{//for local preview
//when the media type is local, set the call handle to -1 (invalid call handle)
var errNo = WrapperProxy.DetachStreamWnd(mediaType, streamId, invalidCallHandle);
if (ErrorNumberEnum.PLCM_SAMPLE_OK != errNo)
{
log.Error("detach stream from window failed. Error number = " + errNo.ToString());
return(false);
}
}
return(true);
}
/// <summary>
/// Updates favorite boolean.
/// </summary>
/// <returns></returns>
private async Task updateFavorites()
{
// Written, 02.02.2020
this.favorite_button.Enabled = false;
this.favorite_button.Text = "processing..";
MediaTypeEnum mediaType = this.media is TvSearchResult ? MediaTypeEnum.tv : MediaTypeEnum.movie;
List <IdResultObject> favoritedMedia = new List <IdResultObject>();
favoritedMedia.AddRange(this.viewAccount.favoritedMovies);
favoritedMedia.AddRange(this.viewAccount.favoritedTvSeries);
bool favorited = favoritedMedia.Any(_fm => _fm.id == this.media.id);
await this.viewAccount.user.favoriteMediaItem(mediaType, media.id, !favorited);
switch (mediaType)
{
case MediaTypeEnum.movie:
await this.viewAccount.retrieveFavoriteMoviesAsync();
break;
case MediaTypeEnum.tv:
await this.viewAccount.retrieveFavoriteTvSeriesAsync();
break;
}
this.updateFavoriteDisplay();
this.favorite_button.Enabled = true;
this.favoriteChanged = true;
}
/// <summary>
/// Delete操作
/// </summary>
/// <summary>
/// Delete请求
/// </summary>
/// <param name="uri">
/// The uri 是指定资源除主机地址外的唯一定位地址.
/// </param>
/// <param name="mediaType">
/// The media Type 是指定数据返回的格式.
/// </param>
/// <param name="header">系统级参数的头信息</param>
/// <typeparam name="T">
/// 获取结果的泛型实体
/// </typeparam>
/// <typeparam name="TResut">The TResult</typeparam>
/// <returns>
/// 返回Put的结果
/// </returns>
public TResut DeleteAsync <TResut>(string uri, MediaTypeEnum mediaType, HeaderRequestInfo header)
{
var defaultT = default(TResut);
// 设置响应格式
httpClient.DefaultRequestHeaders.Accept.Add(HeaderInfoUtility.GetMediaTpye(mediaType));
// 设置系统级参数的响应头
httpClient.DefaultRequestHeaders.SetRequestHeadInfo(header);
Requestheader = header;
// 发送http
var response = httpClient.DeleteAsync(uri).Result;
if (response.IsSuccessStatusCode)
{
defaultT = response.Content.ReadAsAsync <TResut>().Result;
}
// headInfo
ResponseHeader = response.Headers.GetResponseHeadInfo();
return(defaultT);
}
/// <summary>
/// Put请求
/// </summary>
/// <typeparam name="TResut">返回结果的泛型类型</typeparam>
/// <typeparam name="TData">输入参数的泛型类型</typeparam>
/// <param name="uri">指定的uri，不包含主机地址</param>
/// <param name="mediaType">指定的结果返回类型</param>
/// <param name="body">泛型，用于post的请求参数</param>
/// <param name="header">系统级参数的头信息</param>
/// <returns>发送Put请求并返回泛型T的结果</returns>
public TResut PutAsync <TResut, TData>(string uri, MediaTypeEnum mediaType, TData body, HeaderRequestInfo header)
{
var defaultT = default(TResut);
// 设置响应格式
httpClient.DefaultRequestHeaders.Accept.Add(HeaderInfoUtility.GetMediaTpye(mediaType));
// 设置系统级参数的响应头
httpClient.DefaultRequestHeaders.SetRequestHeadInfo(header);
Requestheader = header;
// 发送http
var jsonFormatter = new JsonMediaTypeFormatter();
HttpContent txtContent = new ObjectContent <TData>(body, jsonFormatter);
var response = httpClient.PutAsync(uri, txtContent).Result;
if (response.IsSuccessStatusCode)
{
defaultT = response.Content.ReadAsAsync <TResut>().Result;
}
// ResponseHeader
ResponseHeader = response.Headers.GetResponseHeadInfo();
// Return
return(defaultT);
}
protected void drpMediaType_SelectedIndexChanged(object sender, EventArgs e)
{
MediaTypeEnum type = MediaTypeEnum.Unknown;
switch (drpMediaType.SelectedValue.ToLowerCSafe())
{
case "image":
// Get image dimensions from external source
GetExternalImageDimensions(txtUrl.Text.Trim());
type = MediaTypeEnum.Image;
break;
case "av":
type = MediaTypeEnum.AudioVideo;
break;
case "flash":
type = MediaTypeEnum.Flash;
break;
}
SetLastType(type);
ShowProperties();
}
public void SetObject(IMediaDetail selectedItem)
{
this.selectedItem = selectedItem;
if (selectedItem.ID != 0)
{
var allMediaTypes = MediaTypesMapper.GetDataModel().MediaTypes.Where(i => i.IsActive);
var allowedMediaTypes = new List <MediaType>();
foreach (var mediaType in allMediaTypes)
{
MediaTypeEnum mediaTypeEnum = MediaTypeEnum.Page;
Enum.TryParse(mediaType.Name, out mediaTypeEnum);
var tmpMediaDetail = MediaDetailsMapper.CreateObject(mediaTypeEnum);
if (tmpMediaDetail.GetType() == selectedItem.GetType())
{
allowedMediaTypes.Add(mediaType);
}
}
MediaTypes.DataSource = allowedMediaTypes;
MediaTypes.DataTextField = "Name";
MediaTypes.DataValueField = "ID";
MediaTypes.DataBind();
}
//UpdateFieldsFromObject();
}
public HttpRequest Accepts(MediaTypeEnum contentType)
{
_message.Headers.Accept.Add(
new MediaTypeWithQualityHeaderValue(
contentType.EnumToString()));
return(this);
}
public clsMediaListItem(MediaTypeEnum m, string filename, int MediaID, List<clsSlidePictureItem> slideImages, MOIP.Presentation xPres)
{
this.ID = MediaID;
this.mediaType = m;
this.filename = filename;
this.SlideImages = slideImages;
this.PPTPresentation = xPres;
}
public async Task DownloadToStreamByNameAsync(string gfsname, Stream source, MediaTypeEnum bucketName) {
var bucket = new GridFSBucket(_db, new GridFSBucketOptions
{
BucketName = bucketName.ToString()
});
await bucket.DownloadToStreamByNameAsync(gfsname, source);
}
public GameContent(Game game, uint id, MediaTypeEnum content, QualityEnum quality, AngleEnum angle)
{
Id = new ContentId(id);
Game = game;
Content = content;
Quality = quality;
Angle = angle;
}
public async Task DownloadToStreamAsync(ObjectId id, Stream source, MediaTypeEnum bucketName)
{
var bucket = new GridFSBucket(_db, new GridFSBucketOptions
{
BucketName = bucketName.ToString()
});
await bucket.DownloadToStreamAsync(id, source);
}
public async Task<GridFSDownloadStream> OpenDownloadStreamAsync(ObjectId id, MediaTypeEnum bucketName)
{
var bucket = new GridFSBucket(_db, new GridFSBucketOptions
{
BucketName = bucketName.ToString()
});
return await bucket.OpenDownloadStreamAsync(id);
}
public async Task<GridFSDownloadStream> OpenDownloadStreamByNameAsync(string name, MediaTypeEnum bucketName)
{
var bucket = new GridFSBucket(_db, new GridFSBucketOptions
{
BucketName = bucketName.ToString()
});
return await bucket.OpenDownloadStreamByNameAsync(name);
}
public async Task DownloadToStreamAsync(ObjectId id, Stream source, MediaTypeEnum bucketName)
{
var bucket = new GridFSBucket(_mongoDatabase, new GridFSBucketOptions
{
BucketName = bucketName.ToString()
});
await bucket.DownloadToStreamAsync(id, source);
}
public async Task DownloadToStreamByNameAsync(string gfsname, Stream source, MediaTypeEnum bucketName)
{
var bucket = new GridFSBucket(_mongoDatabase, new GridFSBucketOptions
{
BucketName = bucketName.ToString()
});
await bucket.DownloadToStreamByNameAsync(gfsname, source);
}
public HttpRequest Content(
string content,
MediaTypeEnum mediaType)
{
return(Content(
content,
mediaType.EnumToString(),
Encoding.UTF8));
}
public async Task<byte[]> DownloadAsBytesAsync(ObjectId id, MediaTypeEnum bucketName)
{
var bucket = new GridFSBucket(_db, new GridFSBucketOptions
{
BucketName = bucketName.ToString()
});
return await bucket.DownloadAsBytesAsync(id);
}
/// <summary>
/// Update last type value in dialog selected parameters.
/// </summary>
/// <param name="type">Type</param>
private void SetLastType(MediaTypeEnum type)
{
// Get selected prameters
Hashtable dialogParameters = SessionHelper.GetValue("DialogSelectedParameters") as Hashtable ?? new Hashtable();
// Update last type
dialogParameters[DialogParameters.LAST_TYPE] = type;
SessionHelper.SetValue("DialogSelectedParameters", dialogParameters);
}
public override void SetProperty(string propertyName, object value)
{
switch (propertyName)
{
case "MediaType":
this._mediaTypeEnum = SchemaHelper.ToMediaTypeEnum((string)value);
break;
}
base.SetProperty(propertyName, value);
}
public void AddParameters(
HttpRequestMessage message,
MediaTypeEnum contentType,
IEnumerable <KeyValuePair <string, string> > parameters)
{
message.RequestUri = message
.RequestUri
.AddEncodedQuerystring(
parameters);
}
public static async Task <IList <ServiceItem> > SearchOnline(string keyword, MediaTypeEnum mediatype = MediaTypeEnum.ANIME)
{
if (keyword == string.Empty)
{
return(null);
}
var results = await CurrentService.OnlineSearch(keyword, mediatype);
return(results);
}
public async Task <TResponse> ForProtectedResource <TResponse>(
string baseUrl,
string path,
string httpMethod,
Dictionary <HttpRequestHeader, string> headers,
IDictionary <string, string> querystringParameters,
IDictionary <string, string> pathParameters,
HttpStatusCode expectedResponse = HttpStatusCode.OK,
MediaTypeEnum expectedResponseType = MediaTypeEnum.Json)
{
if (string.IsNullOrEmpty(baseUrl))
{
throw new ArgumentNullException(nameof(baseUrl));
}
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
}
if (string.IsNullOrEmpty(httpMethod))
{
throw new ArgumentNullException(nameof(httpMethod));
}
var request = new HttpRequest(baseUrl)
.Request(
new HttpMethod(httpMethod),
path)
.ResponseMediaType(expectedResponseType)
.Headers(headers)
.Parameters(querystringParameters)
.Segments(pathParameters)
.Authenticator(_authenticator);
if (_parameterHandling == OAuthParameterTypeEnum.Body)
{
request.WithQueryParameters();
}
var response = await request
.ExecuteAsync()
.ConfigureAwait(false);
if (response.StatusCode != expectedResponse)
{
throw new HttpRequestException(string.Format(
StringResources.BadHttpRequestException,
response.StatusCode,
response.Reason));
}
return(await response
.ContentAsync <TResponse>()
.ConfigureAwait(false));
}
public static bool AttachStreamToWindow(IntPtr wndHandle, int callHandle, MediaTypeEnum mediaType, int streamId, int width, int height)
{
log.Debug("[attachStreamToWindow] callHandle:" + callHandle + " mediatype:" + mediaType.ToString() + " streamId:" + streamId + " to window(width: " + width + " height: " + height + " )");
var errNo = WrapperProxy.AttachStreamWnd(mediaType, streamId, callHandle, wndHandle, 0, 0, width, height);
if (ErrorNumberEnum.PLCM_SAMPLE_OK != errNo)
{
log.Error("attach stream to window failed. Error number = " + errNo.ToString());
return(false);
}
return(true);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
string Extention = (string)value;
MediaTypeEnum type = FileManager.GetMediaType(Extention);
switch (type)
{
case MediaTypeEnum.audio: return(@"ImageSources/audio.png");
case MediaTypeEnum.picture: return(@"ImageSources/picture.png");
case MediaTypeEnum.video: return(@"ImageSources/video.png");
}
return(@"ImageSources/undefined.png");
}
internal static MediaTypeEnum ToMediaTypeEnum(string value)
{
MediaTypeEnum mediaTypeEnum = MediaTypeEnum.None;
if (!string.IsNullOrEmpty(value))
{
switch (value)
{
case "TVSeason":
mediaTypeEnum = MediaTypeEnum.TVSeason;
break;
}
}
return(mediaTypeEnum);
}
public async Task<ObjectId> UploadFromStreamAsync(string gfsname, Stream source,string filename, MediaTypeEnum bucketName)
{
var bucket = new GridFSBucket(_db, new GridFSBucketOptions {
BucketName = bucketName.ToString()
});
var options = new GridFSUploadOptions {
Metadata = new BsonDocument {
{ "filename", filename },
{ "contentType", MimeMapping.GetMimeMapping(filename) }
}
};
return await bucket.UploadFromStreamAsync(gfsname, source, options);
}
/// <summary>
/// Favorites or unfavorites a media item.
/// </summary>
/// <param name="inMediaType">The media item type to favorite. Either, <see cref="MediaTypeEnum.movie"/> or <see cref="MediaTypeEnum.tv"/>.</param>
/// <param name="inMediaId">The media's ID.</param>
/// <param name="inWatchlsit">Favorite or unfavorite media item.</param>
public async Task favoriteMediaItem(MediaTypeEnum inMediaType, int inMediaId, bool inFavorite)
{
// Written, 05.12.2019
if (inMediaType != MediaTypeEnum.movie && inMediaType != MediaTypeEnum.tv)
{
throw new ArgumentException("Expected MediaTypeEnum.movie or MediaTypeEnum.tv. invaild argument");
}
string address = String.Format("{0}/{1}/favorite?session_id={2}&api_key={3}", ApplicationInfomation.ACCOUNT_ADDRESS, this.id, this.session.session_id, ApplicationInfomation.API_KEY);
JObject requestData = new JObject(
new JProperty("media_type", inMediaType.ToString()),
new JProperty("media_id", inMediaId),
new JProperty("favorite", inFavorite));
await WebResponse.toJObject(await WebResponse.sendRequestAsync(new Uri(address), System.Text.Encoding.UTF8.GetBytes(requestData.ToString())));
}
public async Task <ObjectId> UploadFromStreamAsync(IFormFile file, MediaTypeEnum bucketName)
{
var bucket = new GridFSBucket(_mongoDatabase, new GridFSBucketOptions
{
BucketName = bucketName.ToString()
});
var options = new GridFSUploadOptions
{
Metadata = new BsonDocument {
{ "filename", file.FileName },
{ "contentType", file.ContentType }
}
};
return(await bucket.UploadFromStreamAsync(file.FileName, file.OpenReadStream(), options));
}
public void AddParameters(
HttpRequestMessage message,
MediaTypeEnum contentType,
IEnumerable <KeyValuePair <string, string> > parameters)
{
if (contentType == MediaTypeEnum.Form)
{
message.Content = new FormUrlEncodedContent(parameters);
}
else if (contentType == MediaTypeEnum.Json)
{
throw new NotImplementedException();
}
else
{
throw new NotImplementedException();
}
}
public void Create_SingleMediaTypeAndSingleDisc_CreatesGivenMediaType()
{
var mediaTypes = new MediaTypeEnum[] { MediaTypeEnum.DVD };
var expectedCount = 3;
CsvRow row = new CsvRow
{
Discs = expectedCount,
MediaType = mediaTypes,
Condition = ConditionClassEnum.Bad
};
var strategy = new SingleMediaTypeStrategy();
var result = strategy.Create(row);
Assert.AreEqual(expectedCount, result.Count);
Assert.AreEqual((int)MediaTypeEnum.DVD, result.First().MediaTypeId);
}
/// <summary>
/// 返回被htpContent封装的内容
/// </summary>
/// <returns></returns>
private HttpContent formateContent <TData>(MediaTypeEnum mediaType, TData body)
{
HttpContent result = null;
switch (mediaType)
{
case MediaTypeEnum.Json:
var jsonFormatter = new JsonMediaTypeFormatter();
result = new ObjectContent <TData>(body, jsonFormatter);
break;
case MediaTypeEnum.Xml:
var xmlFormatter = new XmlMediaTypeFormatter();
result = new ObjectContent <TData>(body, xmlFormatter);
break;
}
return(result);
}
public void Create_TwoMediaTypesAndDiscs_CreatesMediaItemsGivenMediaTypes()
{
var mediaTypes = new MediaTypeEnum[] { MediaTypeEnum.DVD, MediaTypeEnum.BluRay };
var expectedCount = 2;
var row = new CsvRow
{
Discs = expectedCount,
MediaType = mediaTypes,
Condition = ConditionClassEnum.Bad
};
var strategy = new MultipleMatchingCountMediaTypeStrategy();
var result = strategy.Create(row);
Assert.AreEqual(expectedCount, result.Count);
Assert.IsNotNull(result.Where(r => r.MediaTypeId == (int)MediaTypeEnum.DVD).SingleOrDefault());
Assert.IsNotNull(result.Where(r => r.MediaTypeId == (int)MediaTypeEnum.BluRay).SingleOrDefault());
}
public HttpClientEngine(string apiPath, MediaTypeEnum mediaType)
{
client = new HttpClient();
client.BaseAddress = new Uri(apiPath);
if (mediaType == MediaTypeEnum.Json)
{
this.mediaType = "application/json";
}
else
{
this.mediaType = "application/xml";
}
this.apiPath = apiPath;
this.mediaTypeEnum = mediaType;
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(this.mediaType));
}
public HttpClientEngine(string apiPath, MediaTypeEnum mediaType)
{
client = new HttpClient();
client.BaseAddress = new Uri(apiPath);
if (mediaType == MediaTypeEnum.Json)
{
this.mediaType = "application/json";
}
else
{
this.mediaType = "application/xml";
}
this.apiPath = apiPath;
this.mediaTypeEnum = mediaType;
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(this.mediaType));
}
/// <summary>
/// Return webapi data as string from json
/// </summary>
/// <param name="uri">Base address for request</param>
/// <param name="apiUrl">Request Uri</param>
/// <param name="mediaTypeEnum">MediaTypeWithQualityHeaderValue as enum with string value</param>
/// <returns>Returns a list of objects with a request</returns>
public string GetDataJson(Uri uri, string apiUrl, MediaTypeEnum mediaTypeEnum)
{
string dataDo = null;
using (var client = new HttpClient())
{
client.BaseAddress = uri;
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(mediaTypeEnum.GetAttributeValue <EnumValueAttribute, string>(x => x.Value)));
HttpResponseMessage response = client.GetAsync(apiUrl).Result;
if (response.IsSuccessStatusCode)
{
string data = response.Content.ReadAsStringAsync().Result;
dataDo = Newtonsoft.Json.JsonConvert.DeserializeObject <string>(data);
}
}
return(dataDo);
}
private async void watchMediaItem_button_Click(object sender, EventArgs e)
{
// Written, 01.01.2020
this.watchMediaItem_button.Enabled = false;
this.watchMediaItem_button.Text = "processing..";
MediaSearchResult selectedResult = this.searchResults_listView.SelectedItems[0].Tag as MediaSearchResult;
MediaTypeEnum mediaType = selectedResult is TvSearchResult ? MediaTypeEnum.tv : MediaTypeEnum.movie;
List <IdResultObject> watchlistedMedia = new List <IdResultObject>();
watchlistedMedia.AddRange(this.viewAccount.watchlistMovies);
watchlistedMedia.AddRange(this.viewAccount.watchlistTvSeries);
bool watchlisted = watchlistedMedia.Any(_fm => _fm.id == selectedResult.id);
await this.viewAccount.user.watchlistMediaItem(mediaType, selectedResult.id, !watchlisted);
switch (mediaType)
{
case MediaTypeEnum.movie:
await this.viewAccount.retrieveWatchlistMoviesAsync();
break;
case MediaTypeEnum.tv:
await this.viewAccount.retrieveWatchlistTvSeriesAsync();
break;
}
this.watchMediaItem_button.Text = "updating..";
if (mediaType == MediaTypeEnum.movie)
{
await this.updateHomeMoviesAsync();
}
else
{
await this.updateHomeTvSeriesAsync();
}
await this.updateSearchMediaActionsAsync();
this.watchMediaItem_button.Enabled = true;
}
/// <summary>
/// 返回响应类型
/// </summary>
/// <param name="mediaType">
/// 枚举类型 json or xml
/// </param>
/// <returns>
/// The <see cref="MediaTypeWithQualityHeaderValue"/>.
/// </returns>
public static MediaTypeWithQualityHeaderValue GetMediaTpye(MediaTypeEnum mediaType)
{
var pre = "application/";
switch (mediaType)
{
case MediaTypeEnum.Json:
pre = "application/";
break;
case MediaTypeEnum.Xml:
pre = "application/";
break;
case MediaTypeEnum.Plain:
pre = "text/";
break;
}
return(new MediaTypeWithQualityHeaderValue(pre + mediaType.ToString().ToLower()));
}
public piktogramy EditPiktogram(string name, MediaTypeEnum mediumName, object mediumObject = null, string categoryName = null, object image = null)
{
piktogramy pikt = GetPiktogram(name);
pikt.name = name ?? pikt.name;
pikt.media_id = this.AddMedium(mediumName.ToString(), mediumObject);
byte[] img;
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(image as BitmapSource));
using (MemoryStream ms = new MemoryStream())
{
encoder.Save(ms);
img = ms.ToArray();
}
pikt.image = img;
if (categoryName != null)
{
category cat = GetCategory(categoryName);
pikt.category_id = cat.id;
}
db.SaveChanges();
return pikt;
}
/// <summary>
/// Update last type value in dialog selected parameters.
/// </summary>
/// <param name="type">Type</param>
private void SetLastType(MediaTypeEnum type)
{
// Get selected prameters
Hashtable dialogParameters = SessionHelper.GetValue("DialogSelectedParameters") as Hashtable ?? new Hashtable();
// Update last type
dialogParameters[DialogParameters.LAST_TYPE] = type;
SessionHelper.SetValue("DialogSelectedParameters", dialogParameters);
}
public async Task<byte[]> DownloadAsBytesByNameAsync(string gfsname, MediaTypeEnum bucketName) {
var bucket = new GridFSBucket(_db, new GridFSBucketOptions
{
BucketName = bucketName.ToString()
});
return await bucket.DownloadAsBytesByNameAsync(gfsname);
}
public void AddPiktogram(string name, MediaTypeEnum mediumName, object mediumObject, string categoryName)
{
var piktogram = db.CreateObject<piktogramy>();
piktogram.name = name;
piktogram.media_id = this.AddMedium(mediumName.ToString(), mediumObject);
category cat = GetCategory(categoryName);
if (cat == null)
{
AddCategory(categoryName);
cat = GetCategory(categoryName);
}
piktogram.category_id = cat.id;
db.piktogramies.AddObject(piktogram);
db.SaveChanges();
}
public void AddPiktogram(string name, MediaTypeEnum mediumName, object mediumObject, string categoryName, object image)
{
var piktogram = db.CreateObject<piktogramy>();
piktogram.name = name;
piktogram.media_id = this.AddMedium(mediumName.ToString(), mediumObject);
category cat = GetCategory(categoryName);
if (cat == null)
{
AddCategory(categoryName);
cat = GetCategory(categoryName);
}
piktogram.category_id = cat.id;
byte[] img;
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(image as BitmapSource));
using (MemoryStream ms = new MemoryStream())
{
encoder.Save(ms);
img = ms.ToArray();
}
piktogram.image = img;
// bardzo brzydko!
piktogram.id = GetAllPiktograms().Count;
// koniec brzydko
db.piktogramies.AddObject(piktogram);
db.SaveChanges();
}
public AlbumsHttpClient(string apiPath, MediaTypeEnum mediaType)
: base(apiPath, mediaType)
{
}
