public Task CancelScheduledSend <T>(ScheduledMessage <T> message)
where T : class
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
return(CancelScheduledSend(message.TokenId));
}
/// <summary>
/// Cancel a scheduled message using the scheduled message instance
/// </summary>
/// <param name="endpoint">The endpoint of the scheduling service</param>
/// <param name="message">The schedule message reference</param>
public static Task CancelScheduledSend <T>(this ISendEndpoint endpoint, ScheduledMessage <T> message)
where T : class
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
return(CancelScheduledSend(endpoint, message.TokenId));
}
/// <summary>
/// Cancel a scheduled message using the scheduled message instance
/// </summary>
/// <param name="bus"></param>
/// <param name="message"> </param>
public static void CancelScheduledMessage <T>(this IServiceBus bus, ScheduledMessage <T> message)
where T : class
{
if (message == null)
{
throw new ArgumentNullException("message");
}
CancelScheduledMessage(bus, message.TokenId);
}
public async Task <ScheduledMessage <T> > ScheduleSend <T>(T message, DateTime deliveryTime, IPipe <SendContext> sendPipe)
where T : class
{
ISendEndpoint endpoint = await _schedulerEndpoint.Value.ConfigureAwait(false);
ScheduledMessage <T> scheduledMessage = await endpoint.ScheduleSend(_consumeContext.ReceiveContext.InputAddress, deliveryTime, message, sendPipe)
.ConfigureAwait(false);
return(scheduledMessage);
}
private void AddPendingEvent(ScheduledMessage scheduledMessage)
{
ISchedule schedule = scheduleParser.Parse(scheduledMessage.Schedule, scheduledMessage.Details.TimeZoneOffset);
scheduledMessage.Events.Add(new ScheduledMessageEvent
{
NextOccurrence = schedule.GetNextOccurrence(),
State = ScheduledMessageEventState.Pending
});
}
/// <inheritdoc />
protected override async Task <ExecutionResult <string> > ExecuteCoreAsync(Activity activity, string arguments)
{
ExecutionResult <string> result = null;
string[] splitArguments = ArgumentHelper.ParseArguments(arguments);
string messageIdText = splitArguments.ElementAtOrDefault(0);
if (messageIdText != null && Guid.TryParse(messageIdText, out Guid messageId))
{
Logger.LogInformation("Parsed the arguments to message id '{0}'", messageId);
ScheduledMessage scheduledMessage = await UnitOfWork
.ScheduledMessages
.GetActiveByIdWithEventsAsync(messageId);
if (scheduledMessage != null)
{
Logger.LogInformation("Removing scheduled message with id '{0}'", messageId);
scheduledMessage.State = ScheduledMessageState.Deleted;
UnitOfWork.ScheduledMessages.Update(scheduledMessage);
foreach (ScheduledMessageEvent scheduledMessageEvent
in scheduledMessage.Events.Where(@event => @event.State == ScheduledMessageEventState.Pending))
{
Logger.LogInformation("Removing scheduled message event with id '{0}'", scheduledMessageEvent.Id);
scheduledMessageEvent.State = ScheduledMessageEventState.Deleted;
// TODO: Do we need this update operation below?
UnitOfWork.ScheduledMessageEvents.Update(scheduledMessageEvent);
}
await UnitOfWork.SaveChangesAsync();
result = "The event has been removed";
Logger.LogInformation("The scheduled message '{0}' has been removed", messageId);
}
else
{
result = ExecutionResult <string> .Error(
ExecutionErrorCode.SchedulerMessageCannotBeFound,
$"Scheduled message with id '{messageId}' cannot be found");
Logger.LogWarning(result.ErrorMessage);
}
}
else
{
result = ExecutionResult <string> .Error(
ExecutionErrorCode.InputCommandInvalidArguments,
$"Cannot parse the command arguments '{arguments}'");
Logger.LogWarning(result.ErrorMessage);
}
return(result);
}
async Task <ScheduledMessage <T> > IMessageScheduler.ScheduleSend <T>(Uri destinationAddress, DateTime scheduledTime, object values,
IPipe <SendContext> pipe,
CancellationToken cancellationToken)
{
ScheduledMessage <T> scheduledMessage =
await _context.ScheduleSend <T>(destinationAddress, scheduledTime, values, pipe, cancellationToken).ConfigureAwait(false);
AddScheduledMessage(scheduledMessage);
return(scheduledMessage);
}
public async Task <ActionResult <ScheduledMessage> > AddScheduledMessage(ScheduledMessage message)
{
var result = await service.AddScheduledMessage(message);
if (result is null)
{
return(BadRequest("Unable to add message."));
}
return(result);
}
public void Should_have_a_clean_syntax()
{
IServiceBus bus = ServiceBusFactory.New(x => x.ReceiveFrom("loopback://localhost/client"));
using (bus)
{
ScheduledMessage <A> scheduledMessage = bus.ScheduleMessage(5.Seconds().FromNow(), new A());
Assert.IsNotNull(scheduledMessage);
}
}
public void NotDueMessagesAreNotDelivered()
{
var now = _timeSource.UtcNow;
var inOneHour = new ScheduledMessage();
_bus.SendAtTime(now + 1.Hours(), inOneHour);
_timeSource.UtcNow = now + 1.Minutes();
_messageReceiver.ReceivedMessages.Should().BeEmpty();
}
public void DueMessagesAreDelivered()
{
var now = _timeSource.UtcNow;
var inOneHour = new ScheduledMessage();
_bus.SendAtTime(now + 1.Hours(), inOneHour);
_timeSource.UtcNow = now + 1.Hours();
_messageReceiver.ReceivedMessages.Should().Contain(inOneHour);
}
public void Should_reschedule_the_message()
{
ScheduledMessage <A> scheduledMessage = _bus.ScheduleMessage(1.Seconds().FromUtcNow(), new A {
Name = "Joe"
});
_bus.RescheduleMessage(15.Seconds().FromNow(), scheduledMessage);
Assert.IsFalse(_receivedA.WaitOne(10.Seconds()), "Message A handled");
Assert.IsTrue(_receivedA.WaitOne(20.Seconds()), "Message A handled");
}
/// <summary>
/// True if the object is of the type ScheduledMessage and the
/// module name and the contained message match the values
/// this matcher was initialized with.
/// </summary>
/// <param name="obj">
/// The object to compare.
/// </param>
/// <returns>
/// See above.
/// </returns>
public override bool Matches(object obj)
{
if (!(obj is ScheduledMessage))
{
return(false);
}
ScheduledMessage message = (ScheduledMessage)obj;
return((m_moduleName == message.ModuleName) &&
(m_message == message.Message));
}
public async Task Should_be_able_to_cancel_a_future_event()
{
Task <ConsumeContext <A> > handler = SubscribeHandler <A>();
ScheduledMessage <A> scheduledMessage = await Scheduler.ScheduleSend(Bus.Address, DateTime.UtcNow + TimeSpan.FromSeconds(120), new A { Name = "Joe" });
await Task.Delay(2000);
await Scheduler.CancelScheduledSend(scheduledMessage);
await Task.Delay(2000);
}
public void Should_cancel_the_scheduled_message()
{
ScheduledMessage <A> scheduledMessage = _bus.ScheduleMessage(8.Seconds().FromUtcNow(),
new A {
Name = "Joe"
});
_bus.CancelScheduledMessage(scheduledMessage);
Assert.IsFalse(_receivedA.WaitOne(Utils.Timeout), "Message A handled");
Assert.IsFalse(_receivedIA.WaitOne(1.Seconds()), "Message IA handled");
}
protected override void ConfigureServiceBusReceiveEndpoint(IServiceBusReceiveEndpointConfigurator configurator)
{
_first = Handler <FirstMessage>(configurator, async context =>
{
ScheduledMessage <SecondMessage> scheduledMessage = await context.ScheduleSend(DateTime.Now + TimeSpan.FromSeconds(5), new SecondMessage());
await Task.Delay(1000);
await context.CancelScheduledSend(scheduledMessage);
});
_second = Handled <SecondMessage>(configurator);
}
public async Task Queue(ScheduledMessage message, CancellationToken token)
{
using (var lck = await _dbContext.Lock())
{
_dbContext.ScheduledMessageLst.Add(new Models.ScheduledMessageModel
{
ElapsedTime = message.ElapsedTime,
QueueName = message.QueueName,
SerializedContent = message.SerializedContent
});
await _dbContext.SaveChangesAsync(token);
}
}
private ScheduledMessageModel CreateScheduledMessageModel(ScheduledMessageDetails scheduledMessageDetails)
{
ScheduledMessage scheduledMessage = scheduledMessageDetails.ScheduledMessage;
return(new ScheduledMessageModel
{
Id = scheduledMessageDetails.ScheduledMessageId,
Text = scheduledMessage.Text,
State = scheduledMessage.State,
Locale = scheduledMessageDetails.Locale,
NextOccurrences = GetNextOccurrences(scheduledMessageDetails, NextOccurrenceCount)
});
}
public async void Should_properly_send_the_message()
{
Task <ConsumeContext <A> > handlerA = SubscribeHandler <A>();
ScheduledMessage <A> scheduledMessage =
await Bus.ScheduleMessage(DateTime.UtcNow + TimeSpan.FromSeconds(3), new A { Name = "Joe" });
await Task.Delay(1000);
await Bus.CancelScheduledMessage(scheduledMessage);
Assert.Throws <OperationCanceledException>(async() => await handlerA.WithTimeout(5000));
}
public async Task Should_properly_send_the_message()
{
Task <ConsumeContext <A> > handlerA = SubscribeHandler <A>();
ScheduledMessage <A> scheduledMessage =
await Bus.ScheduleSend(Bus.Address, DateTime.UtcNow + TimeSpan.FromSeconds(3), new A { Name = "Joe" });
await Task.Delay(1000);
await Bus.CancelScheduledSend(scheduledMessage);
Assert.That(async() => await handlerA.WithTimeout(5000), Throws.TypeOf <TaskCanceledException>());
}
/// <addNewMessage>
/// Add New Message
/// </summary>
/// <param name="schmesg">Set Values in a ScheduledMessage Class Property and Pass the Object of ScheduledMessage Class.(Domein.ScheduledMessage)</param>
public void addNewMessage(ScheduledMessage schmesg)
{
//Creates a database connection and opens up a session
using (NHibernate.ISession session = SessionFactory.GetNewSession())
{
//After Session creation, start Transaction.
using (NHibernate.ITransaction transaction = session.BeginTransaction())
{
//Proceed action, to save new data.
session.Save(schmesg);
transaction.Commit();
} //End Transaction
} //End Session
}
public override void PostScheduleMessage(dynamic data)
{
try
{
LinkedInAccountRepository linkedinrepo = new LinkedInAccountRepository();
LinkedInAccount linkedinaccount = linkedinrepo.getLinkedinAccountDetailsById(data.ProfileId);
Console.WriteLine("=========================================================================");
// IEnumerable<LinkedInAccount> lstlinkedinaccount = linkedinrepo.getLinkedinAccountDetailsById(data.ProfileId);
//foreach (LinkedInAccount item in lstlinkedinaccount)
//{
// linkedinaccount = item;
// break;
//}
oAuthLinkedIn Linkedin_oauth = new oAuthLinkedIn();
Linkedin_oauth.ConsumerKey = System.Configuration.ConfigurationSettings.AppSettings["LiApiKey"].ToString();
Linkedin_oauth.ConsumerSecret = System.Configuration.ConfigurationSettings.AppSettings["LiSecretKey"].ToString();
Linkedin_oauth.FirstName = linkedinaccount.LinkedinUserName;
Linkedin_oauth.Token = linkedinaccount.OAuthToken;
Linkedin_oauth.TokenSecret = linkedinaccount.OAuthSecret;
Linkedin_oauth.Verifier = linkedinaccount.OAuthVerifier;
LinkedInUser linkeduser = new LinkedInUser();
var response = linkeduser.SetStatusUpdate(Linkedin_oauth, data.ShareMessage);
Console.WriteLine("Message post on linkedin for Id :" + linkedinaccount.LinkedinUserId + " and Message: " + data.ShareMessage);
Console.WriteLine("=============================================================");
ScheduledMessageRepository schrepo = new ScheduledMessageRepository();
ScheduledMessage schmsg = new ScheduledMessage();
schmsg.Id = data.Id;
schmsg.ProfileId = data.ProfileId;
schmsg.ProfileType = "linkedin";
schmsg.Status = true;
schmsg.UserId = data.UserId;
schmsg.ShareMessage = data.ShareMessage;
schmsg.ScheduleTime = data.ScheduleTime;
schmsg.ClientTime = data.ClientTime;
schmsg.CreateTime = data.CreateTime;
schmsg.PicUrl = data.PicUrl;
schrepo.updateMessage(data.Id);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
private async Task PostMessage(DateTime?initialExecutionDateTimeUtc, ScheduledMessage message)
{
IQueueClient queueClient = _queueClientProvider.QueueClient;
string json = JsonConvert.SerializeObject(message);
Message queueMessage = new Message(Encoding.UTF8.GetBytes(json));
queueMessage.MessageId = message.Id;
if (initialExecutionDateTimeUtc.HasValue)
{
queueMessage.ScheduledEnqueueTimeUtc = initialExecutionDateTimeUtc.Value;
}
await queueClient.SendAsync(queueMessage);
}
/// <summary>
/// Cancel a scheduled message
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="scheduler">The message scheduler</param>
/// <param name="message">The </param>
/// <returns></returns>
public static Task CancelScheduledSend <T>(this IMessageScheduler scheduler, ScheduledMessage <T> message)
where T : class
{
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
return(scheduler.CancelScheduledSend(message.Destination, message.TokenId));
}
/// <inheritdoc />
protected override async Task <ExecutionResult <string> > ExecuteCoreAsync(Activity activity, string arguments)
{
ExecutionResult <string> result;
string[] splitArguments = ArgumentHelper.ParseArguments(arguments);
string text = splitArguments.ElementAtOrDefault(0);
string textSchedule = splitArguments.ElementAtOrDefault(1);
if (!string.IsNullOrWhiteSpace(text) && !string.IsNullOrWhiteSpace(textSchedule) && splitArguments.Length == 2)
{
Logger.LogInformation("Parsed the arguments to text '{0}' and schedule '{1}'", text, textSchedule);
if (scheduleParser.TryParse(textSchedule, activity.LocalTimestamp?.Offset, out ISchedule schedule))
{
Logger.LogInformation("Creating a new scheduled message");
ScheduledMessage scheduledMessage = await CreateScheduledMessageAsync(activity, text, schedule);
scheduledMessage = await UnitOfWork.ScheduledMessages.AddAsync(scheduledMessage);
await UnitOfWork.SaveChangesAsync();
string scheduleDescription = scheduleDescriptionFormatter.Format(schedule, activity.Locale);
string createdMessageId = scheduledMessage.Id.ToString();
string newLine = MessageUtils.NewLine;
result = $"New event has been created:{newLine}ID: '{createdMessageId}'{newLine}Schedule: {scheduleDescription}";
Logger.LogInformation("Created a scheduled message with id '{0}'", createdMessageId);
}
else
{
result = ExecutionResult <string> .Error(
ExecutionErrorCode.SchedulerCronCannotRecognize,
$"Cannot recognize schedule \"{textSchedule}\"");
Logger.LogWarning(result.ErrorMessage);
}
}
else
{
result = ExecutionResult <string> .Error(
ExecutionErrorCode.InputCommandInvalidArguments,
"Command arguments are in incorrect format. Use the following pattern: add 'your text' 'your schedule'");
Logger.LogWarning("Cannot parse the command arguments");
}
return(result);
}
private ExecutionResult <string> ExecuteWithMessage(ScheduledMessage message, CultureInfo clientCulture)
{
Logger.LogInformation("Executing with message id '{0}' default message count", message.Id);
ScheduledMessageEvent nextEvent = message
.Events
.Where(@event => @event.State == ScheduledMessageEventState.Pending)
.OrderBy(@event => @event.NextOccurrence)
.FirstOrDefault();
ExecutionResult <string> executionResult = nextEvent != null
? ExecuteWithMessageAndCount(nextEvent.ScheduledMessage, defaultMessageCount, clientCulture)
: GetNoScheduledMessagesResult();
return(executionResult);
}
public async void Should_properly_send_the_message()
{
Task <ConsumeContext <A> > handlerA = SubscribeHandler <A>();
Task <ConsumeContext <IA> > handlerIA = SubscribeHandler <IA>();
ScheduledMessage <A> scheduledMessage =
await Bus.ScheduleMessage(DateTime.UtcNow + TimeSpan.FromSeconds(8), new A { Name = "Joe" });
await Bus.CancelScheduledMessage(scheduledMessage);
await handlerA;
await handlerIA;
}
private static Activity CreateBotMessageActivity(ScheduledMessage scheduledMessage)
{
ScheduledMessageDetails details = scheduledMessage.Details;
Activity activity = (Activity)Activity.CreateMessageActivity();
activity.ServiceUrl = GetLastServiceUrl(details);
activity.From = new ChannelAccount(details.FromId, details.FromName);
activity.Recipient = new ChannelAccount(details.RecipientId, details.RecipientName);
activity.ChannelId = details.ChannelId;
activity.Conversation = new ConversationAccount(id: details.ConversationId);
activity.Locale = details.Locale;
activity.Text = scheduledMessage.Text;
return(activity);
}
private async Task ProcessScheduledMessagesAsync()
{
logger.LogInformation("Starting to process scheduled messages queue");
using (IServiceScope scope = scopeFactory.CreateScope())
{
IUnitOfWork unitOfWork = scope.ServiceProvider.GetRequiredService <IUnitOfWork>();
// TODO: there can be used parallel foreach
IList <ScheduledMessageEvent> scheduledMessageEvents =
await unitOfWork.ScheduledMessageEvents.GetAllPendingWithScheduledMessages(DateTime.UtcNow);
foreach (ScheduledMessageEvent scheduledMessageEvent in scheduledMessageEvents)
{
try
{
ScheduledMessage scheduledMessage = scheduledMessageEvent.ScheduledMessage;
string scheduledMessageId = scheduledMessage.Id.ToString();
logger.LogInformation("Processing scheduled message '{0}'", scheduledMessageId);
await messageProcessor.SendMessageAsync(scheduledMessage, serviceCancellationToken);
scheduledMessageEvent.State = ScheduledMessageEventState.Completed;
AddPendingEvent(scheduledMessage);
logger.LogInformation("Scheduled message '{0}' has been processed", scheduledMessageId);
}
// TODO: Added for debugging purposes, should be revisited.
catch (ErrorResponseException exception)
{
string serializedBody = SafeJsonConvert.SerializeObject(exception.Body, new JsonSerializerSettings {
Formatting = Formatting.Indented
});
string message = $"Sending message was failed due Exception Message: '{exception.Message}', StackTrace: '{exception.StackTrace}', Body: '{serializedBody}'";
logger.LogError(message);
}
catch (Exception exception)
{
logger.LogError(exception, $"Sending message was failed due Exception {exception.Message}. StackTrace: {exception.StackTrace}.");
}
}
await unitOfWork.SaveChangesAsync(serviceCancellationToken);
}
logger.LogInformation("Finished processing scheduled messages queue");
}
/// <summary>
/// Cancel a scheduled message
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="context">The message scheduler</param>
/// <param name="message">The </param>
/// <returns></returns>
public static Task CancelScheduledSend <T>(this ConsumeContext context, ScheduledMessage <T> message)
where T : class
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var scheduler = context.GetPayload <MessageSchedulerContext>();
return(scheduler.CancelScheduledSend(message.Destination, message.TokenId));
}
public string ADDScheduledMessage(string typeandid, string ShareMessage, DateTime ClientTime, DateTime ScheduleTime, bool Status, string UserId, string PicUrl, DateTime CreateTime)
{
try
{
Guid userid = Guid.Parse(UserId);
List<string> type = new List<string>();
List<string> profileid = new List<string>();
string[] TypeandId = typeandid.Split(',');
for (int i = 0; i < TypeandId.Length; i = i + 2)
{
type.Add(TypeandId[i]);
profileid.Add(TypeandId[i + 1]);
}
objScheduledMessage = new Domain.Myfashion.Domain.ScheduledMessage();
try
{
for (int i = 0; i < type.Count; i++)
{
objScheduledMessage.Id = Guid.NewGuid();
objScheduledMessage.ShareMessage = ShareMessage;
objScheduledMessage.ClientTime = ClientTime;
objScheduledMessage.ScheduleTime = ScheduleTime;
objScheduledMessage.CreateTime = CreateTime;
objScheduledMessage.Status = Status;
objScheduledMessage.UserId = userid;
objScheduledMessage.ProfileType = type[i];
objScheduledMessage.PicUrl = PicUrl;
objScheduledMessage.ProfileId = profileid[i];
objScheduledMessageRepository.addNewMessage(objScheduledMessage);
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
Console.WriteLine(ex.StackTrace);
}
ScheduledMessage objScheduledMessages = new ScheduledMessage();
return new JavaScriptSerializer().Serialize(typeandid);
}
catch (Exception ex)
{
logger.Error(ex.Message);
Console.WriteLine(ex.StackTrace);
return new JavaScriptSerializer().Serialize("Please try Again");
}
}
public string UpdateScheduledMessage(string typeidandmsgid, string ShareMessage, DateTime scheduledTime, string picurl)
{
try
{
//Guid msgid = Guid.Parse(MsgId);
List<string> type = new List<string>();
List<string> profileid = new List<string>();
List<string> msgid = new List<string>();
string[] TypeandId = typeidandmsgid.Split(',');
for (int i = 0; i < TypeandId.Length; i = i + 3)
{
type.Add(TypeandId[i]);
profileid.Add(TypeandId[i + 1]);
msgid.Add(TypeandId[i + 2]);
}
ScheduledMessageRepository objScheduledMessageRepository = new ScheduledMessageRepository();
ScheduledMessage objScheduledMessage = new ScheduledMessage();
try
{
for (int i = 0; i < type.Count; i++)
{
objScheduledMessageRepository.UpdateProfileScheduleMessage(Guid.Parse(msgid[i]), profileid[i], ShareMessage, type[i], scheduledTime, picurl);
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
Console.WriteLine(ex.StackTrace);
}
ScheduledMessage objScheduledMessages = new ScheduledMessage();
return new JavaScriptSerializer().Serialize(typeidandmsgid);
}
catch (Exception ex)
{
logger.Error(ex.Message);
Console.WriteLine(ex.StackTrace);
return new JavaScriptSerializer().Serialize("Please try Again");
}
}
public string SheduleFacebookGroupMessage(string FacebookId, string UserId, string sscheduledmsgguid)
{
string str = string.Empty;
int facint = 0;
try
{
objScheduledMessage = objScheduledMessageRepository.GetScheduledMessageDetails(Guid.Parse(sscheduledmsgguid));
GroupScheduleMessageRepository grpschedulemessagerepo = new GroupScheduleMessageRepository();
Domain.Socioboard.Domain.GroupScheduleMessage _GroupScheduleMessage = grpschedulemessagerepo.GetScheduleMessageId(objScheduledMessage.Id);
if (objFacebookAccountRepository.checkFacebookUserExists(FacebookId, Guid.Parse(UserId)))
{
objFacebookAccount = objFacebookAccountRepository.getFacebookAccountDetailsById(FacebookId, Guid.Parse(UserId));
}
else
{
objFacebookAccount = objFacebookAccountRepository.getFacebookAccountDetailsById(FacebookId);
}
if (objFacebookAccount != null)
{
FacebookClient fbclient = new FacebookClient(objFacebookAccount.AccessToken);
var args = new Dictionary<string, object>();
args["message"] = objScheduledMessage.ShareMessage;
string imagepath = objScheduledMessage.PicUrl;
var facebookpost = "";
try
{
if (!string.IsNullOrEmpty(imagepath))
{
var media = new FacebookMediaObject
{
FileName = "filename",
ContentType = "image/jpeg"
};
byte[] img = System.IO.File.ReadAllBytes(imagepath);
media.SetValue(img);
args["source"] = media;
facebookpost = fbclient.Post("v2.0/" + _GroupScheduleMessage.GroupId + "/photos", args).ToString();
}
else
{
facebookpost = fbclient.Post("v2.0/" + _GroupScheduleMessage.GroupId + "/feed", args).ToString();
}
}
catch (Exception ex)
{
objFacebookAccountRepository = new FacebookAccountRepository();
objFacebookAccount.IsActive = 2;
objFacebookAccountRepository.updateFacebookUserStatus(objFacebookAccount);
Domain.Socioboard.Domain.SocialProfile objSocialProfile = new Domain.Socioboard.Domain.SocialProfile();
SocialProfilesRepository objSocialProfilesRepository = new SocialProfilesRepository();
string errormsg = ex.Message;
if (errormsg.Contains("access token"))
{
objSocialProfile.UserId = objFacebookAccount.UserId;
objSocialProfile.ProfileId = objFacebookAccount.FbUserId;
objSocialProfile.ProfileStatus = 2;
objSocialProfilesRepository.updateSocialProfileStatus(objSocialProfile);
}
Console.WriteLine(ex.Message);
str = ex.Message;
}
if (!string.IsNullOrEmpty(facebookpost))
{
facint++;
str = "Message post on facebook for Id :" + objFacebookAccount.FbUserId + " and Message: " + objScheduledMessage.ShareMessage;
ScheduledMessage schmsg = new ScheduledMessage();
schmsg.UpdateScheduledMessageByMsgId(Guid.Parse(sscheduledmsgguid));
logger.Error("SheduleFacebookGroupMessageCount" + facint);
}
}
else
{
str = "facebook account not found for id" + objScheduledMessage.ProfileId;
}
}
catch (Exception ex)
{
str = ex.Message;
}
return str;
}
public string ScheduleLinkedinGroupMessage(string scheduledmsgguid, string Userid, string profileid)
{
string str = string.Empty;
try
{
LinkedInAccount linkacc;
string authLink = string.Empty;
LinkedInAccountRepository linkedinAccRepo = new LinkedInAccountRepository();
objScheduledMessage = objScheduledMessageRepository.GetScheduledMessageDetails(Guid.Parse(scheduledmsgguid));
GroupScheduleMessageRepository grpschedulemessagerepo = new GroupScheduleMessageRepository();
Domain.Socioboard.Domain.GroupScheduleMessage _GroupScheduleMessage = grpschedulemessagerepo.GetScheduleMessageId(objScheduledMessage.Id);
if (linkedinAccRepo.checkLinkedinUserExists(profileid, Guid.Parse(Userid)))
{
linkacc = linkedinAccRepo.getUserInformation(Guid.Parse(Userid), profileid);
}
else
{
linkacc = linkedinAccRepo.getUserInformation(profileid);
}
oAuthLinkedIn oauthlin = new oAuthLinkedIn();
oauthlin.ConsumerKey = ConfigurationManager.AppSettings["LiApiKey"];
oauthlin.ConsumerSecret = ConfigurationManager.AppSettings["LiSecretKey"];
oauthlin.FirstName = linkacc.LinkedinUserName;
oauthlin.Id = linkacc.LinkedinUserId;
oauthlin.Token = linkacc.OAuthToken;
oauthlin.TokenSecret = linkacc.OAuthSecret;
oauthlin.Verifier = linkacc.OAuthVerifier;
string imgurl = objScheduledMessage.PicUrl;
string text = objScheduledMessage.ShareMessage;
string[] arrtext = null;
try
{
arrtext = System.Text.RegularExpressions.Regex.Split(text, "$%^_^%$");
if (arrtext.Count() == 1)
{
arrtext = null;
arrtext = text.Split(new string[] { "$%^_^%$" }, StringSplitOptions.None);
}
}
catch (Exception ex)
{
return "somthing went wrong";
}
string Title = arrtext[0];
string Message = arrtext[1];
string response = string.Empty;
if (linkacc != null)
{
try
{
if (string.IsNullOrEmpty(objScheduledMessage.ShareMessage) && string.IsNullOrEmpty(objScheduledMessage.PicUrl))
{
str = "There is no data in Share Message !";
}
else
{
SocialStream sociostream = new SocialStream();
if (!string.IsNullOrEmpty(imgurl))
{
imgurl = ConfigurationManager.AppSettings["DomainName"].ToString() + Regex.Split(imgurl, "wwwroot")[1].Replace("\\", "/");
response = sociostream.SetImagePostUpdate(oauthlin, _GroupScheduleMessage.GroupId, Message, Title, imgurl);
}
else
{
response = sociostream.SetPostUpdate(oauthlin, _GroupScheduleMessage.GroupId, Message, Title);
}
}
}
catch (Exception ex)
{
}
str = "Message post on linkedingroup for Id :" + linkacc.LinkedinUserId + ", Title: " + Title + " and Message: " + Message;
ScheduledMessage schmsg = new ScheduledMessage();
schmsg.UpdateScheduledMessageByMsgId(Guid.Parse(scheduledmsgguid));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
str = ex.Message;
}
return str;
}
public string SheduleLinkedInMessage(string LinkedInId, string UserId, string sscheduledmsgguid)
{
string str = string.Empty;
LinkedInAccount LinkedAccount;
string authLink = string.Empty;
LinkedInAccountRepository linkedinAccRepo = new LinkedInAccountRepository();
try
{
objScheduledMessage = objScheduledMessageRepository.GetScheduledMessageDetails(Guid.Parse(sscheduledmsgguid));
if (linkedinAccRepo.checkLinkedinUserExists(LinkedInId, Guid.Parse(UserId)))
{
LinkedAccount = linkedinAccRepo.getUserInformation(Guid.Parse(UserId), LinkedInId);
}
else
{
LinkedAccount = linkedinAccRepo.getUserInformation(LinkedInId);
}
oAuthLinkedIn Linkedin_oauth = new oAuthLinkedIn();
Linkedin_oauth.ConsumerKey = System.Configuration.ConfigurationSettings.AppSettings["LiApiKey"].ToString();
Linkedin_oauth.ConsumerSecret = System.Configuration.ConfigurationSettings.AppSettings["LiSecretKey"].ToString();
Linkedin_oauth.FirstName = LinkedAccount.LinkedinUserName;
Linkedin_oauth.Token = LinkedAccount.OAuthToken;
Linkedin_oauth.TokenSecret = LinkedAccount.OAuthSecret;
Linkedin_oauth.Verifier = LinkedAccount.OAuthVerifier;
string message = objScheduledMessage.ShareMessage;
string picurl = objScheduledMessage.PicUrl;
if (LinkedAccount != null)
{
try
{
//GlobusLinkedinLib.App.Core.LinkedInUser linkeduser = new GlobusLinkedinLib.App.Core.LinkedInUser();
if (string.IsNullOrEmpty(objScheduledMessage.ShareMessage) && string.IsNullOrEmpty(objScheduledMessage.PicUrl))
{
//objScheduledMessage.ShareMessage = "There is no data in Share Message !";
str = "There is no data in Share Message !";
}
else
{
var response = string.Empty; ;
try
{
//response = linkeduser.SetStatusUpdate(Linkedin_oauth, objScheduledMessage.ShareMessage);
SocialStream sociostream = new SocialStream();
if (!string.IsNullOrEmpty(picurl))
{
picurl = ConfigurationManager.AppSettings["DomainName"].ToString() + Regex.Split(picurl, "wwwroot")[1].Replace("\\", "/");
response = sociostream.SetImageStatusUpdate(Linkedin_oauth, message, picurl);
}
else
{
response = sociostream.SetStatusUpdate(Linkedin_oauth, message);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
str = ex.Message;
}
if (!string.IsNullOrEmpty(response))
{
str = "Message post on linkedin for Id :" + LinkedAccount.LinkedinUserId + " and Message: " + objScheduledMessage.ShareMessage;
ScheduledMessage schmsg = new ScheduledMessage();
schmsg.UpdateScheduledMessageByMsgId(Guid.Parse(sscheduledmsgguid));
}
else
{
str = "Message not posted";
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
str = ex.Message;
}
}
else
{
str = "Linkedin account not found for id" + objScheduledMessage.ProfileId;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
str = ex.Message;
}
return str;
}
public string SheduleFacebookMessage(string FacebookId, string UserId, string sscheduledmsgguid)
{
string str = string.Empty;
try
{
objScheduledMessage = objScheduledMessageRepository.GetScheduledMessageDetails(Guid.Parse(sscheduledmsgguid));
if (objFacebookAccountRepository.checkFacebookUserExists(FacebookId, Guid.Parse(UserId)))
{
objFacebookAccount = objFacebookAccountRepository.getFacebookAccountDetailsById(FacebookId, Guid.Parse(UserId));
}
else
{
objFacebookAccount = objFacebookAccountRepository.getFacebookAccountDetailsById(FacebookId);
}
if (objFacebookAccount != null)
{
FacebookClient fbclient = new FacebookClient(objFacebookAccount.AccessToken);
var args = new Dictionary<string, object>();
args["message"] = objScheduledMessage.ShareMessage;
string imagepath = objScheduledMessage.PicUrl;
var facebookpost = "";
try
{
if (!string.IsNullOrEmpty(imagepath))
{
try
{
Uri u = new Uri(imagepath);
string filename = string.Empty;
string extension = string.Empty;
extension = Path.GetExtension(u.AbsolutePath).Replace(".", "");
var media = new FacebookMediaObject
{
FileName = "filename",
ContentType = "image/" + extension
};
//byte[] img = System.IO.File.ReadAllBytes(imagepath);
var webClient = new WebClient();
byte[] img = webClient.DownloadData(imagepath);
media.SetValue(img);
args["source"] = media;
facebookpost = fbclient.Post("v2.0/" + objFacebookAccount.FbUserId + "/photos", args).ToString();
}
catch (Exception ex)
{
Console.WriteLine(imagepath + "not Found");
if (!string.IsNullOrEmpty(objScheduledMessage.Url))
{
args["link"] = objScheduledMessage.Url;
}
facebookpost = fbclient.Post("v2.0/" + objFacebookAccount.FbUserId + "/feed", args).ToString();
}
}
else
{
facebookpost = fbclient.Post("v2.0/" + objFacebookAccount.FbUserId + "/feed", args).ToString();
}
}
catch (Exception ex)
{
//FacebookAccount ObjFacebookAccount = new FacebookAccount();
//objFacebookAccount = new Domain.Socioboard.Domain.FacebookAccount();
objFacebookAccountRepository = new FacebookAccountRepository();
//objFacebookAccount.IsActive = 2;
objFacebookAccountRepository.updateFacebookUserStatus(objFacebookAccount);
Domain.Socioboard.Domain.SocialProfile objSocialProfile = new Domain.Socioboard.Domain.SocialProfile();
SocialProfilesRepository objSocialProfilesRepository = new SocialProfilesRepository();
//logger.Error(ex.Message);
string errormsg = ex.Message;
if (errormsg.Contains("access token"))
{
objSocialProfile.UserId = objFacebookAccount.UserId;
objSocialProfile.ProfileId = objFacebookAccount.FbUserId;
objSocialProfile.ProfileStatus = 2;
objSocialProfilesRepository.updateSocialProfileStatus(objSocialProfile);
}
Console.WriteLine(ex.Message);
str = ex.Message;
}
if (!string.IsNullOrEmpty(facebookpost))
{
str = "Message post on facebook for Id :" + objFacebookAccount.FbUserId + " and Message: " + objScheduledMessage.ShareMessage;
ScheduledMessage schmsg = new ScheduledMessage();
schmsg.UpdateScheduledMessageByMsgId(Guid.Parse(sscheduledmsgguid));
}
}
else
{
str = "facebook account not found for id" + objScheduledMessage.ProfileId;
}
}
catch (Exception ex)
{
str = ex.Message;
}
return str;
}
public string SheduleTumblrMessage(string TumblrId, string UserId, string sscheduledmsgguid)
{
string str = string.Empty;
try
{
Guid userId = Guid.Parse(UserId);
oAuthTumbler Obj_oAuthTumbler = new oAuthTumbler();
oAuthTumbler.TumblrConsumerKey = ConfigurationManager.AppSettings["TumblrClientKey"];
oAuthTumbler.TumblrConsumerSecret = ConfigurationManager.AppSettings["TumblrClientSec"];
Obj_oAuthTumbler.TumblrCallBackUrl = ConfigurationManager.AppSettings["TumblrCallBackURL"];
objScheduledMessage = objScheduledMessageRepository.GetScheduledMessageDetails(Guid.Parse(sscheduledmsgguid));
Domain.Socioboard.Domain.TumblrAccount ObjTumblrAccount = objTumblrAccountRepository.getTumblrAccountDetailsById(TumblrId, Guid.Parse(UserId));
oAuthTumbler.TumblrToken = ObjTumblrAccount.tblrAccessToken;
oAuthTumbler.TumblrTokenSecret = ObjTumblrAccount.tblrAccessTokenSecret;
PublishedPosts objPublishedPosts = new PublishedPosts();
string picurl = objScheduledMessage.PicUrl;
string message = objScheduledMessage.ShareMessage;
if (string.IsNullOrEmpty(objScheduledMessage.ShareMessage) && string.IsNullOrEmpty(objScheduledMessage.PicUrl))
{
//objScheduledMessage.ShareMessage = "There is no data in Share Message !";
str = "There is no data in Share Message !";
}
else
{
try
{
//objPublishedPosts.PostData(ObjTumblrAccount.tblrAccessToken, ObjTumblrAccount.tblrAccessTokenSecret, ObjTumblrAccount.tblrUserName, objScheduledMessage.ShareMessage, "", "Text");
if (!string.IsNullOrEmpty(picurl))
{
objPublishedPosts.PostData(ObjTumblrAccount.tblrAccessToken, ObjTumblrAccount.tblrAccessTokenSecret, objScheduledMessage.ProfileId, message, picurl, "photo");
}
else
{
objPublishedPosts.PostData(ObjTumblrAccount.tblrAccessToken, ObjTumblrAccount.tblrAccessTokenSecret, objScheduledMessage.ProfileId, message, "", "text");
}
str = "Message post on tumblr for Id :" + ObjTumblrAccount.tblrUserName + " and Message: " + objScheduledMessage.ShareMessage;
ScheduledMessage schmsg = new ScheduledMessage();
schmsg.UpdateScheduledMessageByMsgId(Guid.Parse(sscheduledmsgguid));
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
str = "Message is not posted";
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
str = ex.Message;
}
return str;
}
private string PostTwitterMessage(String message, String profileid, string userid, string picurl, bool isScheduled, string sscheduledmsgguid = "")
{
bool rt = false;
string ret = "";
string str = "";
Domain.Socioboard.Domain.TwitterAccount objTwitterAccount = objTwitterAccountRepository.GetUserInformation(Guid.Parse(userid), profileid);
oAuthTwitter OAuthTwt = new oAuthTwitter();
OAuthTwt.AccessToken = objTwitterAccount.OAuthToken;
OAuthTwt.AccessTokenSecret = objTwitterAccount.OAuthSecret;
OAuthTwt.TwitterScreenName = objTwitterAccount.TwitterScreenName;
OAuthTwt.TwitterUserId = objTwitterAccount.TwitterUserId;
this.SetCofigDetailsForTwitter(OAuthTwt);
Tweet twt = new Tweet();
if (!string.IsNullOrEmpty(picurl))
{
PhotoUpload ph = new PhotoUpload();
//ph.Tweet(file, message, OAuthTwt);
string res = string.Empty;
rt = ph.NewTweet(picurl, message, OAuthTwt, ref res);
}
else
{
try
{
JArray post = twt.Post_Statuses_Update(OAuthTwt, message);
ret = post[0]["id_str"].ToString();
}
catch { }
}
if (!string.IsNullOrEmpty(ret) || rt == true)
{
if (isScheduled)
{
str = "Message post on twitter for Id :" + objTwitterAccount.TwitterUserId + " and Message: " + objScheduledMessage.ShareMessage;
ScheduledMessage schmsg = new ScheduledMessage();
schmsg.UpdateScheduledMessageByMsgId(Guid.Parse(sscheduledmsgguid));
}
}
else
{
str = "Message not posted";
}
return str;
}
public string GetTeamMembeDetailsForGroupReport(string TeamId, string userid, string days)
{
string FacebookprofileId = string.Empty;
string TwitterprofileId = string.Empty;
string FacebookFanPageId = string.Empty;
string profid = string.Empty;
string FacebookInboxMessagecount = string.Empty;
string TwitterInboxMessagecount = string.Empty;
Domain.Socioboard.Domain.GroupStatDetails _GroupStatDetails = new Domain.Socioboard.Domain.GroupStatDetails();
Guid UserId = Guid.Parse(userid);
try
{
List<FacebookAccount> _facebookAccount = new List<FacebookAccount>();
List<Domain.Socioboard.Domain.TeamMemberProfile> lstTeamMember = teammemberrepo.getAllTeamMemberProfilesOfTeam(Guid.Parse(TeamId));
foreach (Domain.Socioboard.Domain.TeamMemberProfile TeamMemberProfile in lstTeamMember)
{
#region MyRegion
try
{
if (TeamMemberProfile.ProfileType == "facebook" || TeamMemberProfile.ProfileType == "twitter")
{
profid += TeamMemberProfile.ProfileId + ',';
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
try
{
if (TeamMemberProfile.ProfileType == "facebook")
{
FacebookprofileId += TeamMemberProfile.ProfileId + ',';
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
try
{
if (TeamMemberProfile.ProfileType == "twitter")
{
TwitterprofileId += TeamMemberProfile.ProfileId + ',';
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
try
{
if (TeamMemberProfile.ProfileType == "facebook_page")
{
FacebookFanPageId += TeamMemberProfile.ProfileId + ',';
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
#endregion
}
#region MyRegion
try
{
profid = profid.Substring(0, profid.Length - 1);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
try
{
FacebookFanPageId = FacebookFanPageId.Substring(0, FacebookFanPageId.Length - 1);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
try
{
TwitterprofileId = TwitterprofileId.Substring(0, TwitterprofileId.Length - 1);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
try
{
FacebookprofileId = FacebookprofileId.Substring(0, FacebookprofileId.Length - 1);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
#endregion
#region Inboxmessagecount
if (!string.IsNullOrEmpty(FacebookprofileId))
{
try
{
FacebookMessage _FacebookMessage = new FacebookMessage();
FacebookInboxMessagecount = _FacebookMessage.GetAllInboxMessage(userid, FacebookprofileId, days);
}
catch (Exception ex)
{
FacebookInboxMessagecount = (0).ToString();
Console.WriteLine(ex.StackTrace);
}
}
if (!string.IsNullOrEmpty(TwitterprofileId))
{
try
{
TwitterFeed _TwitterFeed = new TwitterFeed();
TwitterInboxMessagecount = _TwitterFeed.TwitterInboxMessagecount(userid, TwitterprofileId, days);
}
catch (Exception ex)
{
TwitterInboxMessagecount = (0).ToString();
Console.WriteLine(ex.StackTrace);
}
}
_GroupStatDetails.IncommingMessage = (Convert.ToInt32(FacebookInboxMessagecount) + Convert.ToInt32(TwitterInboxMessagecount));
#endregion
#region sentmessage
if (!string.IsNullOrEmpty(profid))
{
try
{
ScheduledMessage _ScheduledMessage = new ScheduledMessage();
_GroupStatDetails.SentMessage = _ScheduledMessage.GetAllScheduledMessage(userid, profid, days);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
_GroupStatDetails.SentMessage = 0;
}
}
#endregion
#region twitterfolllower
try
{
TwitterAccountFollowers _TwitterAccountFollowers = new TwitterAccountFollowers();
_GroupStatDetails.TwitterFollower = _TwitterAccountFollowers.FollowerCount(userid, TwitterprofileId, days);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
_GroupStatDetails.TwitterFollower = 0;
}
#endregion
#region fancount
try
{
FacebookFanPage _FacebookFanPage = new FacebookFanPage();
_GroupStatDetails.FacebookFan = _FacebookFanPage.FacebookFans(userid, FacebookFanPageId, days);
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
_GroupStatDetails.FacebookFan = 0;
}
#endregion
#region MentionRetweetDetails
try
{
TwitterMessage _TwitterMessage = new TwitterMessage();
_GroupStatDetails.MentionGraph = string.Empty;
string graphdetails = _TwitterMessage.GetAllRetweetMentionBydays(userid, TwitterprofileId, days);
string[] data = graphdetails.Split('@');
foreach (var item in data)
{
if (item.Contains("usrtwet^"))
{
_GroupStatDetails.UserTweetGraph = item.Replace("usrtwet^", "");
}
else if (item.Contains("mention^"))
{
_GroupStatDetails.MentionGraph = item.Replace("mention^", "");
}
else if (item.Contains("retwet^"))
{
_GroupStatDetails.RetweetGraph = item.Replace("retwet^", "");
}
else if (item.Contains("metion"))
{
_GroupStatDetails.Mention = Convert.ToInt32(item.Replace("metion", ""));
}
else if (item.Contains("retwet"))
{
_GroupStatDetails.Retweet = Convert.ToInt32(item.Replace("retwet", ""));
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
#endregion
try
{
ScheduledMessage _ScheduledMessage = new ScheduledMessage();
string details = _ScheduledMessage.GetAllScheduleMsgDetailsForReport(userid, TwitterprofileId, days);
string[] data = details.Split('@');
foreach (var item in data)
{
if (item.Contains("plaintext_"))
{
_GroupStatDetails.PlainText = Convert.ToInt32(item.Replace("plaintext_",""));
}
else
{
_GroupStatDetails.PhotoLink = Convert.ToInt32(item);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
return "Something Went Wrong";
}
return new JavaScriptSerializer().Serialize(_GroupStatDetails);
}
