public PostSummary(string URLTitle, DateTime date, PostType type)
{
PartitionKey= date.Year.ToString();
RowKey = URLTitle;
Type = type;
Date = date;
}
public async Task <bool> AddToFavourite(User user, PostType postType, string postId)
{
if (user is null)
{
return(false);
}
string postIdComplate = ',' + postId;
switch (postType)
{
case PostType.Company: user.FavouriteCompanies += postIdComplate;
break;
case PostType.Contestant: user.FavouriteContestants += postIdComplate;
break;
case PostType.Job: user.FavouriteJobs += postIdComplate;
break;
}
user.ActivityReaded = false;
await _userManager.UpdateAsync(user);
return(true);
}
public async Task <IActionResult> Edit(int?id, [FromBody] PostType postType)
{
try
{
if (id == null)
{
return(BadRequest());
}
else
{
var postTypeToUpdate = _context.PostTypes.FirstOrDefault(p => p.PostTypeId == id);
if (postTypeToUpdate == null)
{
return(NotFound());
}
else
{
postTypeToUpdate.CreatedDate = postType.CreatedDate;
postTypeToUpdate.PostTypeName = postType.PostTypeName;
postTypeToUpdate.SortOrder = postType.SortOrder;
postTypeToUpdate.ModifiedDate = DateTime.Now;
_context.Entry(postTypeToUpdate).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(new ObjectResult(postTypeToUpdate));
}
}
}
catch
{
return(BadRequest());
}
}
public async Task LoadMorePosts(
PostType type, int count, int offset)
{
ShowLoadingMoreGrid();
try
{
var result = await PostApi.Get(
SettingsManager.PersistentSettings.CurrentUser.Token,
type, count, offset)
.ConfigureAwait(true);
if (result == null)
{
return;
}
result.Data ??= new List <PostSchema>();
await AddMorePosts(result.Data)
.ConfigureAwait(true);
}
finally
{
HideLoadingMoreGrid();
}
}
// GET: BlogEntries
public ActionResult Index(PostType PostType)
{
ViewBag.topics = PostType.topics;
ViewBag.Author = db.Users.Where(u => u.Id == db.Posts.FirstOrDefault().AuthorId).FirstOrDefault().DisplayName;
if (PostType == PostType.date)
{
//ViewBag.Date = PostType.Remove(0, 4).Split({20, 21});
ViewBag.PostType = PostType;
ViewBag.topics = PostType.topics;
var indexedPosts = db.Posts.Where(p => p.CreationDate.Year == 2020).ToList();
return(View(indexedPosts));
}
if (PostType == PostType.topics)
{
var indexedPosts = db.Posts.Where(p => p.Published == true);
ViewBag.Topic0 = PostType.MVC;
ViewBag.Topic1 = PostType.Photography;
ViewBag.Topic2 = PostType.TED_Talks;
ViewBag.Topic3 = PostType.Brain_Teasers;
ViewBag.PostType = PostType.topics;
ViewBag.topics = PostType.topics;
return(View(indexedPosts));
}
else
{
var indexedPosts = db.Posts.Where(p => p.PostType == PostType).ToList().Where(p => p.Published == true);
ViewBag.Topic = PostType;
ViewBag.PostType = PostType;
return(View(indexedPosts));
}
}
public AliExpressPoster(
string restAPIUrl,
string restAPIKey,
string restAPISecret,
PostType postType,
double priceMarkupPercentage,
double usdToMyrCurrencyRate,
double productMinPriceAfterConvert,
double productBelowMinMarkup)
{
this.restAPIKey = restAPIKey;
this.restAPISecret = restAPISecret;
this.postType = postType;
this.priceMarkupPercentage = priceMarkupPercentage;
this.usdToMyrCurrencyRate = usdToMyrCurrencyRate;
this.productMinPriceAfterConvert = productMinPriceAfterConvert;
this.productBelowMinMarkup = productBelowMinMarkup;
RestAPI rest = new RestAPI(
restAPIUrl,
this.restAPIKey,
this.restAPISecret);
wc = new WCObject(rest);
}
public static void UpdatePostType(PostType postType, out StringBuilder errors)
{
errors = new StringBuilder();
try
{
using (var db = new ApplicationDbContext())
{
var fetchedPostType = GetPostTypeById(postType.Id);
if (fetchedPostType == null)
{
errors.Append("Post Type does not exist.\n");
return;
}
fetchedPostType.Slug = postType.Slug;
fetchedPostType.Category = postType.Category;
fetchedPostType.SubCategory = postType.SubCategory;
db.PostTypes.AddOrUpdate(fetchedPostType);
db.SaveChanges();
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private Response Post(string stepName, string url, object parameters, PostType type)
{
RecordStepStart(stepName);
var client = GetWebClient();
try
{
switch (type)
{
case PostType.Form:
_data = client.UploadValues(url, NameValueCollectionConversions.ConvertFromObject(parameters));
break;
case PostType.Json:
var serializer = new JavaScriptSerializer();
client.Headers.Add("Content-Type", "application/json; charset=utf-8");
_data = client.UploadData(url, Encoding.UTF8.GetBytes(serializer.Serialize(parameters)));
client.Headers.Remove("Content-Type");
break;
}
return(BuildResponse(client.Response));
}
catch (WebException)
{
return(BuildErrorResponse());
}
finally
{
RecordStepEnd(stepName);
}
}
public static void WriteJson(this PostType value, JsonWriter writer, JsonSerializer serializer)
{
switch (value)
{
case PostType.Post: serializer.Serialize(writer, "post"); break;
}
}
public PostPerson(long personId, long postId, long levelId, PostType postType)
{
PersonId = personId;
PostId = postId;
if (postType == PostType.CentralOrganization)
{
CentralOrganizationId = levelId;
}
else if (postType == PostType.BranchProvince)
{
BranchProvinceId = levelId;
}
else if (postType == PostType.University)
{
UniversityId = levelId;
}
else if (postType == PostType.College)
{
CollegeId = levelId;
}
else if (postType == PostType.EducationalGroup)
{
EducationalGroupId = levelId;
}
else if (postType == PostType.FieldofStudy)
{
FieldofStudyId = levelId;
}
}
public async Task <List <Notice> > GetUpcomingEvents(int page, PostType all)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var resp = await _noticeService.GetUpcomingEvents(userId);
return(resp);
}
/// <summary>
/// Additional default constructer to define a place with specific type of related posts..
/// for ex: place with mistakes only, or place with supplications only. etc..
/// </summary>
/// <param name="postDataType"> that has post and anlylize its content</param>
/// <param name="relatedPostFilter"> the type of related posts which we need the filter with it</param>
public PlaceDetailsPage(PostDataType postDataType, PostType relatedPostFilter, string title)
{
postData = postDataType;
relatedFilter = relatedPostFilter;
this.Title = title;
Init();
}
public PlaceDetailsPage(PostDataType postDataType)
{
postData = postDataType;
relatedFilter = PostType.Place;// default filter is place whear everyting is showing
this.Title = postData.Title;
Init();
}
/// <summary>
/// 创建新的帖子编辑模型
/// </summary>
public async Task <PostEditModel> CreateNewEditModelAsync(PostType defaultType, PersonView person)
{
if (person == null)
{
throw new ArgumentNullException(nameof(person));
}
using (var work = this.dbFactory.StartWork())
{
PostEditModel model = new PostEditModel();
model.PostType = defaultType;
// 创建话题列表
model.TopicSelectItems.Add(new SelectListItem("选择话题分类...", ""));
List <Topic> topics = new List <Topic>();
if (person.RoleType == RoleType.Admin || person.RoleType == RoleType.SuperAdmin)
{
topics = await work.Topic.GetAllAsync(SearchType.Visible, true);
}
else
{
topics = await work.Topic.GetAllAsync(SearchType.Visible, false);
}
foreach (var topic in topics)
{
model.TopicSelectItems.Add(new SelectListItem(topic.Name, topic.Id.ToString()));
}
;
List <string> BestTags = (await work.Tag.GetBestAsync()).Select(p => p.Name).ToList();
model.BestTags = JsonConvert.SerializeObject(BestTags);
return(model);
}
}
public async Task <IEnumerable <PostPreviewDto> > GetSimilarPosts(PostType type = PostType.None)
{
int number = type == PostType.None ? 6 : 3;
var posts = await _getRandomPostPreviewsQueryHandler.HandleAsync(new GetRandomPostPreviewsQuery(type, number));
return(posts);
}
/// <summary>
/// FORM表单解析
/// </summary>
/// <param name="dataToType"></param>
internal void ParseForm(PostType dataToType = PostType.Data)
{
switch (HttpHeader.PostType)
{
case PostType.Json: Form.SetText(GetFormText(), Http.Header.QueryJsonNameChar); return;
case PostType.Xml: Form.SetText(GetFormText(), Http.Header.QueryXmlNameChar); return;
case PostType.Data:
if (FormBufferReceiveEndIndex == 0)
{
return;
}
switch (dataToType)
{
case PostType.Json: Form.SetText(GetFormText(), Http.Header.QueryJsonNameChar); return;
case PostType.Xml: Form.SetText(GetFormText(), Http.Header.QueryXmlNameChar); return;
default: return;
}
default: Form.Parse(); return;
}
}
public static PostTypeDto ToDto(PostType postType)
{
return(new PostTypeDto
{
PostType = postType.PostTypeValue
});
}
public string PostString(string data, PostType postType, string contentType = null)
{
try
{
Request.Method = "POST";
Request.ContentType = contentType ?? "application/json";
if (postType == PostType.Byte)
{
byte[] byteArray = Encoding.ASCII.GetBytes(data);
Request.ContentLength = byteArray.Length;
Stream inStream = Request.GetRequestStream();
inStream.Write(byteArray, 0, byteArray.Length);
inStream.Close();
}
else
{
Request.ContentLength = data.Length;
Stream inStream = Request.GetRequestStream();
StreamWriter writeStream = new StreamWriter(inStream);
writeStream.Write(data);
writeStream.Flush();
}
var response = (HttpWebResponse)Request.GetResponse();
using (Stream rpRead = response.GetResponseStream())
{
StreamReader stReader = new StreamReader(rpRead, Encoding.ASCII);
string outPutRD = stReader.ReadToEnd().Trim();
return(outPutRD);
}
}
catch (Exception)
{
throw;
}
}
public Post(User owner, PostType type, string fileName, DateTime postedDate)
{
Owner = owner;
Type = type;
FileName = fileName;
PostedDate = postedDate;
}
public PostData(T item)
{
var boxedType = item.GetType();
if (typeof(byte[]).AssignableFrom(boxedType))
{
WrittenBytes = item as byte[]; Type = PostType.ByteArray;
}
else if (typeof(string).AssignableFrom(boxedType))
{
_literalString = item as string; Type = PostType.LiteralString;
}
else if (typeof(IEnumerable <string>).AssignableFrom(boxedType))
{
_enumurabeOfStrings = (IEnumerable <string>)item; Type = PostType.EnumerableOfString;
}
else if (typeof(IEnumerable <object>).AssignableFrom(boxedType))
{
_enumerableOfObject = (IEnumerable <object>)item; Type = PostType.EnumerableOfObject;
}
else
{
_serializable = item; Type = PostType.Serializable;
}
}
/// <summary>
/// Delete User Action Activity Log
/// </summary>
/// <param name=></param>
/// <returns>bool</returns>
public async Task <bool> DeletePostType(int PostTypeId)
{
#region Declare a return type with initial value.
bool isPostTypeDeleted = default(bool);
#endregion
try
{
if (PostTypeId > default(int))
{
#region Vars
PostType PostType = null;
#endregion
#region Get PostType by id
PostType = await UnitOfWork.PostTypeRepository.GetById(PostTypeId);
#endregion
#region check if object is not null
if (PostType != null)
{
PostType.IsDeleted = (byte)DeleteStatusEnum.Deleted;
#region Apply the changes to the database
UnitOfWork.PostTypeRepository.Update(PostType);
isPostTypeDeleted = await UnitOfWork.Commit() > default(int);
#endregion
}
#endregion
}
}
catch (Exception exception)
{
}
return(isPostTypeDeleted);
}
public async Task CreateMethodShouldAddPostInDatabase(string title, PostType type, string description, int categoryId)
{
var guid = Guid.NewGuid().ToString();
var options = new DbContextOptionsBuilder <ForumDbContext>()
.UseInMemoryDatabase(guid)
.Options;
var db = new ForumDbContext(options);
var dateTimeProvider = new Mock <IDateTimeProvider>();
var usersServiceMock = new Mock <IUsersService>();
dateTimeProvider.Setup(dtp => dtp.Now()).Returns(new DateTime(2020, 3, 27));
usersServiceMock.Setup(us => us.AddPointsAsync(guid, 1)).ReturnsAsync(1);
var postsService = new PostsService(db, null, usersServiceMock.Object, dateTimeProvider.Object);
var expectedIds = new[] { 1, 2, 3 };
var postId = await postsService.CreateAsync(title, type, description, guid, categoryId, expectedIds);
var actual = await db.Posts.FirstOrDefaultAsync();
var actualTagIds = actual.Tags.Select(t => t.TagId).ToArray();
postId.Should().Be(1);
db.Posts.Should().HaveCount(1);
actualTagIds.Should().BeEquivalentTo(expectedIds);
}
public override MvcHtmlString WriteButton(HtmlHelper helper, object htmlAttributes)
{
// Provide default value for PostUrl in case it hasn't been specified.
if (string.IsNullOrWhiteSpace(PostUrl))
{
UrlHelper Url = new UrlHelper(helper.ViewContext.RequestContext);
PostUrl = Url.Action("Postback");
}
TagBuilder tb = new TagBuilder("input");
tb.Attributes.Add("type", "button");
tb.Attributes.Add("class", "ExpressFormsModifyDataButton");
tb.Attributes.Add("value", Text);
tb.Attributes.Add("data-posturl", PostUrl);
tb.Attributes.Add("data-actiontype", ActionType.ToString());
tb.Attributes.Add("data-posttype", PostType.ToString());
tb.Attributes.Add("data-formname", FormName);
tb.Attributes.Add("data-message", ConfirmationMessage);
tb.Attributes.Add("data-id", Convert.ToString(IdForDeletion));
tb.Attributes.Add("data-tableid", TableIdForDeletion);
if (!IsVisible)
{
tb.Attributes.Add("style", "display: none;");
}
IDictionary <string, object> efHtmlAttributes = new RouteValueDictionary(htmlAttributes);
foreach (var kvp in efHtmlAttributes)
{
tb.MergeAttribute(kvp.Key, Convert.ToString(kvp.Value));
}
return(new MvcHtmlString(tb.ToString(TagRenderMode.SelfClosing)));
}
private bool isCheckin(string text, string source)
{
bool checkin = false;
PostType pType = getPostType(source);
switch (pType)
{
case PostType.Foursquare:
checkin = true;
break;
case PostType.Instagram:
checkin = false;
break;
case PostType.Twitter:
checkin = false;
break;
case PostType.Other:
checkin = false;
break;
default:
break;
}
return(checkin);
}
private void SwitchSearchType(PostType postType)
{
if (postType == _presenter.PostType)
{
return;
}
_presenter.PostType = postType;
switch (postType)
{
case PostType.Hot:
hotConstrain.Active = true;
topConstraint.Active = newConstraint.Active = false;
break;
case PostType.New:
newConstraint.Active = true;
topConstraint.Active = hotConstrain.Active = false;
break;
case PostType.Top:
topConstraint.Active = true;
hotConstrain.Active = newConstraint.Active = false;
break;
}
UIView.Animate(0.2, 0, UIViewAnimationOptions.CurveEaseOut, () =>
{
View.LayoutIfNeeded();
}, null);
GetPosts(true, true);
}
/// <summary>
/// Constructor for attribute applied against a controller action method. This
/// will create test data using the values of the action.
/// </summary>
/// <param name="position">The position of the test relative to all other tests</param>
/// <param name="formId">The name of the form that will be submitted</param>
/// <param name="postType">The type of data to be posted to the controller action</param>
/// <param name="response">The expected response for the result, 200, 404 etc</param>
/// <param name="method">The web method used when submitting the test, GET, POST, PUT etc</param>
/// <param name="inputData">The data that will be submitted for the test, this must be a colon seperated list of strings representing parameter values to be submitted or can also be raw json or XML.</param>
/// <param name="searchData">A colon seperated list of string that can be searched for within the response after either a get or prior to data being submitted via a form.</param>
/// <param name="submitSearchData">A colon seperated list of strings that can be searched for in the response after data has been submitted.</param>
/// <param name="name">Name of the test, used to identify it, if not specified then the controller and action name will be used.</param>
/// <param name="parameters">Name value pair of valid parameter values for this test</param>
/// <param name="redirectUrl">The expected url where the response will be redirected to.</param>
public SmokeTestAttribute(int response,
PostType postType = PostType.Form,
string formId = "",
int position = 10000,
string method = "",
string inputData = "",
string searchData = "",
string submitSearchData = "",
string name = "",
string parameters = "",
string redirectUrl = "/")
{
IsFromControllerAction = true;
Response = response;
PostType = postType;
Position = position;
Method = method;
InputData = inputData;
SubmitSearchData = submitSearchData;
SearchData = searchData;
Name = name;
FormId = formId;
Parameters = parameters;
RedirectUrl = redirectUrl;
}
private void watcher_FileCreated(object sender, FileSystemEventArgs e)
{
if (e.ChangeType == WatcherChangeTypes.Created)
{
try
{
if (e.FullPath == m_shellContentMenuFilePath)
{
string _fileContents;
using (StreamReader _textFile = new StreamReader(m_shellContentMenuFilePath))
{
_fileContents = _textFile.ReadToEnd();
}
m_delayPostType = PostType.Photo;
m_delayPostPicList = new List <string>
{
_fileContents
};
}
}
catch
{
}
}
File.Delete(m_shellContentMenuFilePath);
}
public async Task AddReactionFromPost(string UserId, int PostId, PostType postType, ReactionType reactionType)
{
var reaction = GetReaction(UserId, PostId, postType);
if (reaction == null)
{
reaction = new Reaction
{
UserId = UserId,
PostId = PostId,
PostType = postType,
ReactionType = reactionType
};
_context.Reactions.Add(reaction);
}
else
{
if (reaction.ReactionType == reactionType)
{
return;
}
reaction.ReactionType = reactionType;
_context.Reactions.Update(reaction);
}
await _context.SaveChangesAsync();
}
public override int GetHashCode()
{
unchecked
{
int result = Id.GetHashCode();
result = (result * 397) ^ (Urn != null ? Urn.GetHashCode() : 0);
result = (result * 397) ^ UserId.GetHashCode();
result = (result * 397) ^ DateAdded.GetHashCode();
result = (result * 397) ^ DateModified.GetHashCode();
result = (result * 397) ^ (TargetUserId.HasValue ? TargetUserId.Value.GetHashCode() : 0);
result = (result * 397) ^ (ForwardedPostId.HasValue ? ForwardedPostId.Value.GetHashCode() : 0);
result = (result * 397) ^ OriginUserId.GetHashCode();
result = (result * 397) ^ (OriginUserName != null ? OriginUserName.GetHashCode() : 0);
result = (result * 397) ^ SourceUserId.GetHashCode();
result = (result * 397) ^ (SourceUserName != null ? SourceUserName.GetHashCode() : 0);
result = (result * 397) ^ (SubjectUrn != null ? SubjectUrn.GetHashCode() : 0);
result = (result * 397) ^ (ContentUrn != null ? ContentUrn.GetHashCode() : 0);
result = (result * 397) ^ (TrackUrns != null ? TrackUrns.GetHashCode() : 0);
result = (result * 397) ^ (Caption != null ? Caption.GetHashCode() : 0);
result = (result * 397) ^ CaptionUserId.GetHashCode();
result = (result * 397) ^ (CaptionSourceName != null ? CaptionSourceName.GetHashCode() : 0);
result = (result * 397) ^ (ForwardedPostUrn != null ? ForwardedPostUrn.GetHashCode() : 0);
result = (result * 397) ^ PostType.GetHashCode();
result = (result * 397) ^ (OnBehalfOfUserId.HasValue ? OnBehalfOfUserId.Value.GetHashCode() : 0);
return(result);
}
}
/// <summary>
/// Returns a pageable collection of entries ordered by the id descending.
/// This is used in the admin section.
/// </summary>
public override IPagedCollection <EntryStatsView> GetEntries(PostType postType, int?categoryId, int pageIndex, int pageSize)
{
using (IDataReader reader = _procedures.GetEntries(BlogId, categoryId, pageIndex, pageSize, (int)postType))
{
return(reader.ReadPagedCollection(r => reader.ReadEntryStatsView()));
}
}
private Post GetFirstPostWhere(StringBuilder sb, PostType postType, Func <Post, bool> func)
{
var getPosts = new PostsModel(postType);
Post testPost;
do
{
var postsResp = _api.GetPosts(getPosts, CancellationToken.None)
.Result;
if (!postsResp.IsSuccess)
{
sb.AppendLine($"fail. Reason:{Environment.NewLine} {postsResp.Error.Message}");
return(null);
}
if (postsResp.Result.Results.Count == 0)
{
sb.AppendLine("fail. Reason:{Environment.NewLine} There are no Posts!");
return(null);
}
testPost = postsResp.Result.Results.FirstOrDefault(func);
if (testPost == null)
{
getPosts.Offset = postsResp.Result.Results.Last().Url;
}
} while (testPost == null);
return(testPost);
}
public Entry(PostType postType, Blog blog)
{
Categories = new List<string>();
PostConfig = PostConfig.None;
DateModifiedUtc = NullValue.NullDateTime;
DateCreatedUtc = NullValue.NullDateTime;
PostType = postType;
Blog = blog;
Id = NullValue.NullInt32;
}
public void Parse()
{
var split = Thid.Split(':');
Thid1 = split[0];
Thid2 = split[1];
Type = (PostType)Int32.Parse(split[2]);
Thid4 = split[3];
Thid5 = split[4];
Thid6 = split[5];
}
public static void GoTo(PostType postType)
{
switch (postType)
{
case PostType.Page:
LeftNavigation.Pages.AllPages.Select();
break;
default:
break;
}
}
public static PostList GetPostAll(string token, string keywords, PostType postType, string maxID, int pagesize=20)
{
var paras = new Dictionary<string, object>();
paras.Add("access_token", token);
paras.Add("keywords", keywords);
paras.Add("post_type",(int) postType);
paras.Add("max_id", maxID);
paras.Add("pagesize", pagesize);
var result = HttpRequest.RequestServer(ApiOption.post_v2_all, paras);
return JsonConvert.DeserializeObject<PostList>(result);
}
public static MvcHtmlString GetPostClassByType(this HtmlHelper helper, PostType type)
{
switch (type)
{
case PostType.SimplePost:
return new MvcHtmlString("simple-post");
case PostType.VideoPost:
return new MvcHtmlString("video-post");
default:
throw new InvalidEnumArgumentException("Unknown post type!");
}
}
public PostListViewModel(PostType postType, INavigationService navigationService, System.Action<bool> NotifyLoading)
{
_navigationService = navigationService;
_ErrorMessage = "";
_Posts = new BindableCollection<PostItem>();
_IsLoading = false;
NotifyLoadingAction = NotifyLoading;
PostType = postType;
Load();
}
private string MarkPostUpOrDown(Post post, Member postWriter, Member voter, PostType postType)
{
// Check this user is not the post owner
if (voter.Id != postWriter.Id)
{
// Not the same person, now check they haven't voted on this post before
if (post.Votes.All(x => x.MemberId != CurrentMember.Id))
{
// Points to add or subtract to a user
var usersPoints = (postType == PostType.Negative) ?
(-Settings.PointsDeductedForNegativeVote) : (Settings.PointsAddedForPositiveVote);
// Update the users points who wrote the post
ServiceFactory.MemberPointsService.Add(new MemberPoints
{
Points = usersPoints,
Member = postWriter,
MemberId = postWriter.Id,
RelatedPostId = post.Id
});
// Update the post with the new vote of the voter
var vote = new Vote
{
Post = post,
Member = voter,
MemberId = voter.Id,
Amount = (postType == PostType.Negative) ? (-1) : (1),
VotedByMember = CurrentMember,
DateVoted = DateTime.Now
};
ServiceFactory.VoteService.Add(vote);
// Update the post with the new points amount
var allVotes = post.Votes.ToList();
var allVoteCount = allVotes.Sum(x => x.Amount);
//var newPointTotal = (postType == PostType.Negative) ? (post.VoteCount - 1) : (post.VoteCount + 1);
post.VoteCount = allVoteCount;
var postTypeVoteCount = 0;
if (postType == PostType.Positive)
{
postTypeVoteCount = allVotes.Count(x => x.Amount > 0);
}
else
{
postTypeVoteCount = allVotes.Count(x => x.Amount < 0);
}
return string.Concat(postTypeVoteCount, ",", allVoteCount);
}
}
return "0";
}
public static void GoTo(PostType postType)
{
switch (postType)
{
case PostType.Page:
//Refactor:
LeftNavigation.Pages.AllPages.Select();
break;
case PostType.Posts:
LeftNavigation.Posts.AllPosts.Select();
break;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DraftPost"/> class.
/// </summary>
/// <param name="post">
/// The post.
/// </param>
public DraftPost(Post post)
{
this._fileID = post.FileID;
this._type = PostType.Draft;
this._catID = post.CatID;
this._oldCatID = this._catID;
this._title = post.Title;
this._author = post.Author;
this._time = post.Time;
this._comments = post.Comments;
this._docs = post.Documents;
this._contents = post.Contents;
}
public void Send(string tags, PostType type, bool receivecopy)
{
using (MailMessage msg = new MailMessage())
{
foreach (KeyValuePair<string, Stream> attachment in m_attachments)
{
msg.Attachments.Add(new Attachment(attachment.Value, attachment.Key));
m_html = m_html.Replace(attachment.Key, "cid:" + attachment.Key);
}
msg.From = new MailAddress(m_senderemail, "gdocerous");
msg.ReplyToList.Add(new MailAddress(m_email));
if (type == PostType.Private)
msg.To.Add(new MailAddress("*****@*****.**"));
else if (type == PostType.Draft)
msg.To.Add(new MailAddress("*****@*****.**"));
else if (type == PostType.Public)
msg.To.Add(new MailAddress("*****@*****.**"));
if (receivecopy)
msg.Bcc.Add(new MailAddress(m_email));
msg.Subject = string.Format("{0} ((tag: {1}))", m_documenttitle, tags);
AlternateView htmlView = AlternateView.CreateAlternateViewFromString(m_html, new System.Net.Mime.ContentType("text/html"));
foreach (KeyValuePair<string, Stream> attachment in m_attachments)
{
LinkedResource linkedRes = new LinkedResource(attachment.Value, GetMediaType(attachment.Key));
linkedRes.ContentId = attachment.Key;
htmlView.LinkedResources.Add(linkedRes);
}
msg.AlternateViews.Add(htmlView);
using (var smtp = new SmtpClient())
{
smtp.Send(msg);
}
}
}
public static string Update(string token, string msg, string gID, PostShareType shareType, PostType postType, out int errorCode)
{
errorCode = 0;
var paras = new Dictionary<string, object>();
paras.Add("access_token", token);
paras.Add("p_msg", msg);
paras.Add("g_id", gID);
paras.Add("s_type", (int)shareType);
paras.Add("p_type", (int)postType);
var result = HttpRequest.RequestServer(ApiOption.post_update, paras);
JObject resultObj =(JObject) JsonConvert.DeserializeObject(result);
if (resultObj != null)
{
if (resultObj.Property("error_code") == null)
return resultObj["post"].ToString();
else
errorCode =int.Parse( resultObj["error_code"].ToString());
}
return string.Empty;
}
private static void ValidateEntryTypeIsNotNone(PostType entryType)
{
Debug.Assert(entryType != PostType.None, "The entry type is none. This should be impossible!");
}
public async Task<Tuple<List<RedditPost>, string, string>> LoadPostsAsync(string suffix, PostSort sort, PostType type, int countViewed, string after)
{
var posts = new Tuple<List<RedditPost>, string, string>(new List<RedditPost>(), "", "");
switch (type)
{
case PostType.All:
switch (sort)
{
case PostSort.Controversial:
posts = await Helpers.Posts.FindControversialPostsAsync(suffix, countViewed, after);
break;
case PostSort.Hot:
posts = await Helpers.Posts.FindHotPostsAsync(suffix, countViewed, after);
break;
case PostSort.New:
posts = await Helpers.Posts.FindNewPostsAsync(suffix, countViewed, after);
break;
case PostSort.Rising:
posts = await Helpers.Posts.FindRisingPostsAsync(suffix, countViewed, after);
break;
case PostSort.Top:
default:
posts = await Helpers.Posts.FindTopPostsAsync(suffix, countViewed, after);
break;
}
break;
case PostType.Pics:
switch (sort)
{
case PostSort.Controversial:
posts = await Helpers.Pics.FindControversialPicsAsync(suffix, countViewed, after);
break;
case PostSort.Hot:
posts = await Helpers.Pics.FindHotPicsAsync(suffix, countViewed, after);
break;
case PostSort.New:
posts = await Helpers.Pics.FindNewPicsAsync(suffix, countViewed, after);
break;
case PostSort.Rising:
posts = await Helpers.Pics.FindRisingPicsAsync(suffix, countViewed, after);
break;
case PostSort.Top:
default:
posts = await Helpers.Pics.FindTopPicsAsync(suffix, countViewed, after);
break;
}
break;
case PostType.SelfText:
switch (sort)
{
case PostSort.Controversial:
posts = await Helpers.SelfText.FindControversialSelfTextAsync(suffix, countViewed, after);
break;
case PostSort.Hot:
posts = await Helpers.SelfText.FindHotSelfTextAsync(suffix, countViewed, after);
break;
case PostSort.New:
posts = await Helpers.SelfText.FindNewSelfTextAsync(suffix, countViewed, after);
break;
case PostSort.Rising:
posts = await Helpers.SelfText.FindRisingSelfTextAsync(suffix, countViewed, after);
break;
case PostSort.Top:
default:
posts = await Helpers.SelfText.FindTopSelfTextAsync(suffix, countViewed, after);
break;
}
break;
}
return posts;
}
private string PostContent(string username, string password, ref Post post, bool publish, PostType postType)
{
Framework.BlogInfo info = Config.CurrentBlog;
ValidateUser(username, password, info.AllowServiceAccess);
Entry entry = new Entry(postType);
entry.Author = info.Author;
entry.Email = info.Email;
entry.Body = post.description;
entry.Title = post.title;
entry.Description = string.Empty;
//TODO: Figure out why this is here.
// Probably means the poster forgot to set the date.
DateTime dateTimeInPost = Config.CurrentBlog.TimeZone.ToLocalTime(post.dateCreated);
var lastEntryDate = DbProvider.Instance().GetLatestEntryDate();
if (dateTimeInPost.Year >= 2003)
{
// this is an indication that we want to move the rest of the posts
if (dateTimeInPost.AddHours(-1) <= Config.CurrentBlog.TimeZone.Now)
{
DbProvider.Instance().PushOtherPostsDatesAfter(dateTimeInPost);
}
entry.DateCreated = dateTimeInPost;
entry.DateModified = dateTimeInPost;
}
else
{
if (lastEntryDate == null) // there is no next entry date
{
entry.DateCreated = Config.CurrentBlog.TimeZone.Now;
}
else if (lastEntryDate.Value.AddDays(1) < Config.CurrentBlog.TimeZone.Now) // the latest date it too far in the past
{
entry.DateCreated = Config.CurrentBlog.TimeZone.Now;
}
else
{
// noon the next day
entry.DateCreated = lastEntryDate.Value.Date.AddDays(1).AddHours(12);
entry.Body = "<blockquote>Originally posted at " + Config.CurrentBlog.TimeZone.Now.ToShortDateString() +
"</blockquote>" + entry.Body;
}
entry.DateModified = entry.DateCreated;
}
if (post.categories != null)
{
entry.Categories.AddRange(post.categories);
}
if (!string.IsNullOrEmpty(post.wp_slug))
{
entry.EntryName = post.wp_slug;
}
entry.PostType = postType;
entry.IsActive = publish;
if (publish)
{
entry.DateSyndicated = entry.DateCreated;
}
entry.AllowComments = true;
entry.DisplayOnHomePage = true;
entry.IncludeInMainSyndication = true;
entry.IsAggregated = true;
entry.SyndicateDescriptionOnly = false;
int postID;
try
{
postID = Entries.Create(entry);
if (!string.IsNullOrEmpty(post.enclosure.url))
{
Components.Enclosure enc = new Components.Enclosure();
enc.Url = post.enclosure.url;
enc.MimeType = post.enclosure.type;
enc.Size = post.enclosure.length;
enc.EntryId = postID;
Enclosures.Create(enc);
}
AddCommunityCredits(entry);
}
catch (Exception e)
{
throw new XmlRpcFaultException(0, e.Message + " " + e.StackTrace);
}
if (postID < 0)
{
throw new XmlRpcFaultException(0, "The post could not be added");
}
return postID.ToString(CultureInfo.InvariantCulture);
}
/// <summary> /// Returns a pageable collection of entries ordered by the id descending. /// This is used in the admin section. /// </summary> /// <param name="postType">Type of the post.</param> /// <param name="categoryId">The category ID.</param> /// <param name="pageIndex">Index of the page.</param> /// <param name="pageSize">Size of the page.</param> /// <returns></returns> public abstract IPagedCollection<EntryStatsView> GetEntries(PostType postType, int? categoryId, int pageIndex, int pageSize);
private string PostContent(string username, string password, ref Post post, bool publish, PostType postType)
{
ValidateUser(username, password, Blog.AllowServiceAccess);
var entry = new Entry(postType) {PostType = postType, IsActive = publish, Author = Blog.Author, Email = Blog.Email};
post.CopyValuesTo(entry);
entry.AllowComments = true;
entry.DisplayOnHomePage = true;
DateTime dateTimeInPost = post.dateCreated != null ? post.dateCreated.Value : DateTime.UtcNow;
// Store in the blog's timezone
dateTimeInPost = Blog.TimeZone.FromUtc(dateTimeInPost);
entry.DateCreated = entry.DateModified = Blog.TimeZone.Now;
if(publish)
{
entry.DateSyndicated = dateTimeInPost;
}
entry.IncludeInMainSyndication = true;
entry.IsAggregated = true;
entry.SyndicateDescriptionOnly = false;
int postId;
try
{
//TODO: Review whether keywords should be true.
postId = EntryPublisher.Publish(entry);
if(Blog.TrackbacksEnabled)
{
NotificationServices.Run(entry, Blog, Url);
}
if(post.enclosure != null)
{
Components.Enclosure enclosure = post.enclosure.Value.CopyValuesToEnclosure();
enclosure.EntryId = postId;
Repository.Create(enclosure);
}
AddCommunityCredits(entry);
}
catch(Exception e)
{
throw new XmlRpcFaultException(0, e.Message + " " + e.StackTrace);
}
if(postId < 0)
{
throw new XmlRpcFaultException(0, Resources.XmlRpcFault_AddPostFailed);
}
return postId.ToString(CultureInfo.InvariantCulture);
}
public static string FormatPostText(string rawPostBody, PostType postType, bool allowCustomTransforms)
{
string formattedPost = rawPostBody;
// because of the way we receive the post from MSHTML, somethings can already be encoded. This breaks the regex patterns
// so we're unencoding anything that is already encoded so regex patterns work correctly. Later we'll encode everything again.
//SCOTTW: Why? Encoded markup should stay encoded...otherwise it will not render
//formattedPost = HttpUtility.HtmlDecode( formattedPost );
if (allowCustomTransforms ) {
// must do emoteicons first because they are restricted from finding any inside [code][/code] blocks. We have to do
// this before the later steps remove the [code][/code] blocks.
if( CSContext.Current.SiteSettings.EnableEmoticons ) {
formattedPost = EmoticonTransforms(formattedPost);
}
}
// convert any html inside code/pre blocks into encoded html
formattedPost = EncodeCodeBlocks( formattedPost );
// strip the html posts of any offending html tags and encode any that don't meet the criteria.
formattedPost = HtmlScrubber.Clean(formattedPost,false,true);// ScrubHtml( formattedPost, postType );
// convert all html tags to bbcode as the bbcode processor will only allow safe attributes to be included in the ponst.
// formattedPost = HtmlToBBCode( formattedPost );
// Remove any script code
//
// formattedPost = Transforms.StripScriptTags(formattedPost);
// Peform specialized transforms first.
//
// Do BBCode transform, if any
//
formattedPost = BBcodeToHtml(formattedPost);
// Perform HTML Encoding of any tag elements, if not PostType.HTML
//
if (postType != PostType.HTML && postType != PostType.Poll) {
formattedPost = HttpUtility.HtmlEncode(formattedPost);
formattedPost = formattedPost.Replace("\n", Globals.HtmlNewLine);
// Fix to reverse certain items that were HtmlEncoded above
//
formattedPost = UnHtmlEncode(formattedPost);
}
return formattedPost;
}
/// <summary>
///
/// </summary>
/// <param name="encodedString"></param>
/// <param name="postType"></param>
/// <returns></returns>
static string ScrubHtml( string encodedString, PostType postType )
{
System.Collections.Hashtable ht = GetAllowedTags();
System.Text.StringBuilder sb = new System.Text.StringBuilder();
encodedString = Regex.Replace(encodedString, @"(<!--)", @"<!--", RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.IgnorePatternWhitespace );
encodedString = Regex.Replace(encodedString, @"(-->)", @"-->", RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.IgnorePatternWhitespace );
// string[] blocks = Regex.Split(encodedString, @"((<(?:\/)?\w+(?:\s+\w+(?:\s*=\s*""?\w+""?)?)*\s*(?:\/)?>)|(<\!--)|(-->))", RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.IgnorePatternWhitespace );
// string[] blocks = Regex.Split(encodedString, @"\b(<(?:\/)?\w+(?:\s+\w+(?:\s*=\s*""?(?:[\w-_:#\'\s%]*|(?:(?:http|ftp|https):\/\/)?[\w-_]+(?:\.[\w-_]+)+(?:[\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?)""?)?)*\s*(?:\/)?>)", RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.IgnorePatternWhitespace );
// string[] blocks = Regex.Split(encodedString, @"(<(?:\/)?\w+\s*(?:\w+)*\s*(?:\/)?>)", RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.IgnorePatternWhitespace );
string[] blocks = Regex.Split(encodedString, @"\b<(\/?\w*)(\s*(\w*)(?:\s*=\s*(?:""[^""]*""|'[^']'|[^>]*))?)*\/?>\b", RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.IgnorePatternWhitespace );
string output = "";
int keyStart = 1;
foreach( string block in blocks ) {
output = block;
if( output.StartsWith("<") ) {
if( output[1] == '/' )
keyStart = 2;
else
keyStart = 1;
int keyEnd = output.IndexOfAny(new char[]{' ', '/', '>'}, keyStart) - keyStart;
string key = output.Substring(keyStart, keyEnd).ToLower();
StringBuilder sbAttr = new StringBuilder();
if( ht.ContainsKey( key )) {
string slashClosing = output.EndsWith("/>") ? "/" : "";
string slashOpening = output.StartsWith("</") ? "/" : "";
string attributes = (string)ht[key];
if( attributes != null && attributes.Length > 0 ) {
string[] allowedAttr = ((string)ht[key]).Split(',');
//foreach( Match match in Regex.Matches(output, String.Format(@"<{0}((?:\s+(\w+)(?:\s*=""?\w+""?)?)*)?\s*[\/\?]?>", key), RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace )) {
//foreach( Match match in Regex.Matches(output, String.Format(@"<{0}((?:\s+(\w+)(?:\s*=\s*""?(?:\w*|(?:(?:http|ftp|https):\/\/)?[\w-_]+(?:\.[\w-_]+)+(?:[\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?)""?)?)*)\s*[\/\?]?>", key), RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace )) {
string attrPattern = String.Format(@"<{0}(\s*(\w*)(?:\s*=\s*(?:""[^""]*""|'[^']'|[^>]*))?)*\/?>", key);
MatchCollection matches = Regex.Matches(output, attrPattern, RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace );
foreach( Match match in matches ) {
foreach( string attr in allowedAttr ) {
if( match.Groups[2].Captures[0].Value == attr ) {
sbAttr.Append( match.Groups[1].Captures[0].Value );
}
}
}
}
sb.AppendFormat("<{0}{1}{2}{3}>", slashOpening, key, sbAttr.ToString(), slashClosing );//Regex.Replace( output, (string)ht[key], "<$1 $2>$3</$1>", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace ) );
}
else {
sb.Append( HttpUtility.HtmlEncode( output ) );
}
}
else {
sb.Append( output );
}
}
return sb.ToString();
}
/*
public void GetBlogQueue(string blogHostName)
{
if (String.IsNullOrEmpty(blogHostName))
throw new ArgumentException("invalid blog host name");
var client = GetRestClient();
var resource = string.Format("/blog/{0}/posts/queue", blogHostName);
var request = new RestRequest(resource, Method.GET);
var response = client.Execute(request);
Console.WriteLine(response.StatusCode);
}*/
//TODO: Write some overloads for this
public List<TumblrPost> GetBlogPosts(string blogHostName, PostFormat format = PostFormat.Html, string filteredTag = "", bool includeReblogs = false, bool includeNotes = false, int offset = 0, int limit = 20, PostType postType = PostType.All )
{
if (String.IsNullOrEmpty(blogHostName))
throw new ArgumentException("invalid blog host name");
var client = GetUnAuthenticatedRestClient();
string typeUrl = "";
switch (postType)
{
case PostType.Text:
typeUrl = "/text";
break;
case PostType.Quote:
typeUrl = "/quote";
break;
case PostType.Link:
typeUrl = "/link";
break;
case PostType.Audio:
typeUrl = "/audio";
break;
case PostType.Video:
typeUrl = "/video";
break;
case PostType.Answer:
typeUrl = "/answer";
break;
case PostType.Photo:
typeUrl = "/photo";
break;
default:
typeUrl = "";
break;
}
//post type on end of url for this one
var resource = string.Format("/blog/{0}/posts{1}", blogHostName, typeUrl);
var request = new RestRequest(resource);
request.AddParameter(new Parameter() { Name = "api_key", Type = ParameterType.GetOrPost, Value = ConsumerKey });
request.AddParameter("limit", limit);
request.AddParameter("offset", offset);
if(filteredTag != "")
request.AddParameter("tag", filteredTag);
request.AddParameter("reblog_info", includeReblogs);
request.AddParameter("notes_info", includeNotes);
var response = client.Execute<TumblrResponse<TumblrPostsResponse>>(request);
return ConvertPosts(response.Data.Response.Posts);
}
/// <summary> /// Gets the entries that meet the <see cref="PostType"/> and /// <see cref="PostConfig"/> flags. /// </summary> /// <param name="itemCount">Item count.</param> /// <param name="postType">The type of entry to return.</param> /// <param name="postConfig">Post Configuration options.</param> /// <param name="includeCategories">Whether or not to include categories</param> /// <returns></returns> public abstract ICollection<Entry> GetEntries(int itemCount, PostType postType, PostConfig postConfig, bool includeCategories);
public abstract ICollection<Entry> GetPostsByDayRange(DateTime start, DateTime stop, PostType postType, bool activeOnly);
public async Task<bool> LoadMorePostsAsync(string suffix, PostSort sort, PostType type)
{
Tuple<List<RedditPost>, string, string> posts = await LoadPostsAsync(suffix, sort, type, CountViewed, AfterPost);
foreach (RedditPost p in posts.Item1)
{
Posts.Add(p);
}
BeforePost = posts.Item2;
AfterPost = posts.Item3;
await CheckPostStuff();
CountViewed += 25;
_loading = false;
return true;
}
/// <summary> /// Returns the previous and next entry to the specified entry. /// </summary> /// <param name="entryId"></param> /// <param name="postType"></param> /// <returns></returns> public abstract ICollection<EntrySummary> GetPreviousAndNextEntries(int entryId, PostType postType);
/// <summary>
/// Asynchronously retrieves posts from the current user's dashboard.
/// </summary>
/// See: http://www.tumblr.com/docs/en/api/v2#m-ug-dashboard
/// <param name="sinceId">
/// Return posts that have appeared after the specified ID. Use this parameter to page through the results: first get a set
/// of posts, and then get posts since the last ID of the previous set.
/// </param>
/// <param name="startIndex">
/// The post number to start at.
/// </param>
/// <param name="count">
/// The number of posts to return.
/// </param>
/// <param name="type">
/// The <see cref="PostType"/> to return.
/// </param>
/// <param name="includeReblogInfo">
/// Whether or not the response should include reblog info.
/// </param>
/// <param name="includeNotesInfo">
/// Whether or not the response should include notes info.
/// </param>
/// <returns>
/// A <see cref="Task{T}"/> that can be used to track the operation. If the task succeeds, the <see cref="Task{T}.Result"/> will
/// carry an array of posts. Otherwise <see cref="Task.Exception"/> will carry a <see cref="TumblrException"/>
/// representing the error occurred during the call.
/// </returns>
/// <exception cref="ObjectDisposedException">
/// The object has been disposed.
/// </exception>
/// <exception cref="InvalidOperationException">
/// This <see cref="TumblrClient"/> instance does not have an OAuth token specified.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// <list type="bullet">
/// <item>
/// <description>
/// <paramref name="sinceId"/> is less than 0.
/// </description>
/// </item>
/// <item>
/// <description>
/// <paramref name="startIndex"/> is less than 0.
/// </description>
/// </item>
/// <item>
/// <description>
/// <paramref name="count"/> is less than 1 or greater than 20.
/// </description>
/// </item>
/// </list>
/// </exception>
public Task<BasePost[]> GetDashboardPostsAsync(long sinceId = 0, long startIndex = 0, int count = 20, PostType type = PostType.All, bool includeReblogInfo = false, bool includeNotesInfo = false)
{
if (disposed)
throw new ObjectDisposedException("TumblrClient");
if (sinceId < 0)
throw new ArgumentOutOfRangeException("sinceId", "sinceId must be greater or equal to zero.");
if (startIndex < 0)
throw new ArgumentOutOfRangeException("startIndex", "startIndex must be greater or equal to zero.");
if (count < 1 || count > 20)
throw new ArgumentOutOfRangeException("count", "count must be between 1 and 20.");
if (OAuthToken == null)
throw new InvalidOperationException("GetDashboardPostsAsync method requires an OAuth token to be specified.");
MethodParameterSet parameters = new MethodParameterSet();
parameters.Add("type", type.ToString().ToLowerInvariant(), "all");
parameters.Add("since_id", sinceId, 0);
parameters.Add("offset", startIndex, 0);
parameters.Add("limit", count, 0);
parameters.Add("reblog_info", includeReblogInfo, false);
parameters.Add("notes_info", includeNotesInfo, false);
return CallApiMethodAsync<PostCollection, BasePost[]>(
new UserMethod("dashboard", OAuthToken, HttpMethod.Get, parameters),
r => r.Posts,
CancellationToken.None);
}
public static string FormatPostText(string rawPostBody, PostType postType)
{
return FormatPostText (rawPostBody, postType, true);
}
public Entry(PostType postType)
: this(postType, Config.CurrentBlog)
{
}
/// <summary>
/// Asynchronously retrieves published posts from a blog.
/// </summary>
/// <remarks>
/// See: http://www.tumblr.com/docs/en/api/v2#posts
/// </remarks>
/// <param name="blogName">
/// The name of the blog.
/// </param>
/// <param name="startIndex">
/// The offset at which to start retrieving the posts. Use 0 to start retrieving from the latest post.
/// </param>
/// <param name="count">
/// The number of posts to retrieve. Must be between 1 and 20.
/// </param>
/// <param name="type">
/// The <see cref="PostType"/> to retrieve.
/// </param>
/// <param name="includeReblogInfo">
/// Whether or not to include reblog info with the posts.
/// </param>
/// <param name="includeNotesInfo">
/// Whether or not to include notes info with the posts.
/// </param>
/// <param name="filter">
/// A <see cref="PostFilter"/> to apply.
/// </param>
/// <param name="tag">
/// A tag to filter by.
/// </param>
/// <returns>
/// A <see cref="Task{T}"/> that can be used to track the operation. If the task succeeds, the <see cref="Task{T}.Result"/> will
/// carry a <see cref="Posts"/> instance. Otherwise <see cref="Task.Exception"/> will carry a <see cref="TumblrException"/>
/// representing the error occurred during the call.
/// </returns>
/// <exception cref="ObjectDisposedException">
/// The object has been disposed.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="blogName"/> is <b>null</b>.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="blogName"/> is empty.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// <list type="bullet">
/// <item>
/// <description>
/// <paramref name="startIndex"/> is less than 0.
/// </description>
/// </item>
/// <item>
/// <description>
/// <paramref name="count"/> is less than 1 or greater than 20.
/// </description>
/// </item>
/// </list>
/// </exception>
public Task<Posts> GetPostsAsync(string blogName, long startIndex = 0, int count = 20, PostType type = PostType.All, bool includeReblogInfo = false, bool includeNotesInfo = false, PostFilter filter = PostFilter.Html, string tag = null)
{
if (disposed)
throw new ObjectDisposedException("TumblrClient");
if (blogName == null)
throw new ArgumentNullException("blogName");
if (blogName.Length == 0)
throw new ArgumentException("Blog name cannot be empty.", "blogName");
if (startIndex < 0)
throw new ArgumentOutOfRangeException("startIndex", "startIndex must be greater or equal to zero.");
if (count < 1 || count > 20)
throw new ArgumentOutOfRangeException("count", "count must be between 1 and 20.");
string methodName = null;
switch (type)
{
case PostType.Text: methodName = "posts/text"; break;
case PostType.Quote: methodName = "posts/quote"; break;
case PostType.Link: methodName = "posts/link"; break;
case PostType.Answer: methodName = "posts/answer"; break;
case PostType.Video: methodName = "posts/video"; break;
case PostType.Audio: methodName = "posts/audio"; break;
case PostType.Photo: methodName = "posts/photo"; break;
case PostType.Chat: methodName = "posts/chat"; break;
case PostType.All:
default: methodName = "posts"; break;
}
MethodParameterSet parameters = new MethodParameterSet();
parameters.Add("api_key", apiKey);
parameters.Add("offset", startIndex, 0);
parameters.Add("limit", count, 0);
parameters.Add("reblog_info", includeReblogInfo, false);
parameters.Add("notes_info", includeNotesInfo, false);
parameters.Add("filter", filter.ToString().ToLowerInvariant(), "html");
parameters.Add("tag", tag);
return CallApiMethodAsync<Posts>(
new BlogMethod(blogName, methodName, null, HttpMethod.Get, parameters),
CancellationToken.None);
}
protected override object this[string index]
{
get
{
#region
switch (index)
{
case "GuildID": return GuildID;
case "UserID": return UserID;
case "PostType": return PostType;
case "Contribution": return Contribution;
case "TotalContribution": return TotalContribution;
case "IncenseNum": return IncenseNum;
case "IncenseDate": return IncenseDate;
case "DevilNum": return DevilNum;
case "SummonNum": return SummonNum;
case "IsDevil": return IsDevil;
case "DevilDate": return DevilDate;
case "InsertDate": return InsertDate;
case "GainBlessing": return GainBlessing;
case "CurrNum": return CurrNum;
case "RefreshDate": return RefreshDate;
case "DonateCoin": return DonateCoin;
case "DonateGold": return DonateGold;
case "TotalDonate": return TotalDonate;
default: throw new ArgumentException(string.Format("GuildMember index[{0}] isn't exist.", index));
}
#endregion
}
set
{
#region
switch (index)
{
case "GuildID":
_GuildID = value.ToNotNullString();
break;
case "UserID":
_UserID = value.ToNotNullString();
break;
case "PostType":
_PostType = value.ToEnum<PostType>();
break;
case "Contribution":
_Contribution = value.ToInt();
break;
case "TotalContribution":
_TotalContribution = value.ToInt();
break;
case "IncenseNum":
_IncenseNum = value.ToInt();
break;
case "IncenseDate":
_IncenseDate = value.ToDateTime();
break;
case "DevilNum":
_DevilNum = value.ToInt();
break;
case "SummonNum":
_SummonNum = value.ToInt();
break;
case "IsDevil":
_IsDevil = value.ToInt();
break;
case "DevilDate":
_DevilDate = value.ToDateTime();
break;
case "InsertDate":
_InsertDate = value.ToDateTime();
break;
case "GainBlessing":
_GainBlessing = value.ToInt();
break;
case "CurrNum":
_CurrNum = value.ToInt();
break;
case "RefreshDate":
_RefreshDate = value.ToDateTime();
break;
case "DonateCoin":
_DonateCoin = value.ToInt();
break;
case "DonateGold":
_DonateGold = value.ToInt();
break;
case "TotalDonate":
_TotalDonate = value.ToInt();
break;
default: throw new ArgumentException(string.Format("GuildMember index[{0}] isn't exist.", index));
}
#endregion
}
}
private void MarkPostUpOrDown(Post post, MembershipUser postWriter, MembershipUser voter, PostType postType)
{
// Check this user is not the post owner
if (voter.Id != postWriter.Id)
{
// Not the same person, now check they haven't voted on this post before
if (post.Votes.All(x => x.User.Id != LoggedOnUser.Id))
{
// Points to add or subtract to a user
var usersPoints = (postType == PostType.Negative) ?
(-SettingsService.GetSettings().PointsDeductedNagativeVote) : (SettingsService.GetSettings().PointsAddedPostiveVote);
// Update the users points who wrote the post
_membershipUserPointsService.Add(new MembershipUserPoints { Points = usersPoints, User = postWriter });
// Update the post with the new vote of the voter
var vote = new Vote
{
Post = post,
User = voter,
Amount = (postType == PostType.Negative) ? (-1) : (1),
VotedByMembershipUser = LoggedOnUser,
DateVoted = DateTime.UtcNow
};
_voteService.Add(vote);
// Update the post with the new points amount
var newPointTotal = (postType == PostType.Negative) ? (post.VoteCount - 1) : (post.VoteCount + 1);
post.VoteCount = newPointTotal;
}
}
}
