public async Task <ActionResult <string> > AssignUser(int id, [FromBody] SubscribeDTO subscribeDTO)
{
var request = await _requestRepository.GetRequestById(id);
var user = await _userRepository.GetUserById(subscribeDTO.UserId);
if (request != null && user != null)
{
request.DesignatedUser = user;
user.Jobs.Add(request);
await _requestRepository.UpdateRequest(request);
await _userRepository.UpdateUser(user);
var resultToReturn = request;
return(Ok("Assigned successfully"));
}
if (request == null && user == null)
{
return(Problem("User and Request do not exist", statusCode: (int)HttpStatusCode.BadRequest));
}
else if (user == null)
{
return(Problem("User does not exist", statusCode: (int)HttpStatusCode.BadRequest));
}
else if (request == null)
{
return(Problem("Request does not exist", statusCode: (int)HttpStatusCode.BadRequest));
}
return(BadRequest());
}
public IHttpActionResult Subscribe([FromBody] SubscribeDTO subscribeDTO)
{
var device = deviceService.GetByCode(subscribeDTO.DeviceCode);
if (device == null)
{
return(BadRequest());
}
var store = storeService.GetByQR(subscribeDTO.StoreQR);
if (store == null)
{
return(BadRequest());
}
StoreDevice subscribtion = new StoreDevice()
{
DeviceID = device.DeviceID,
StoreID = store.StoreID,
DateCreated = DateTime.UtcNow
};
deviceService.Subscribe(subscribtion);
deviceService.SaveDevice();
return(Ok());
}
public async Task <ActionResult <string> > Subscribe(int id, [FromBody] SubscribeDTO subscribeDTO)
{
var request = await _requestRepository.GetRequestById(id);
var user = await _userRepository.GetUserById(subscribeDTO.UserId);
// Sanity Check
if (request == null)
{
return(BadRequest());
}
request.Subscribe(user);
user.Subscribe(request);
if (!request.Subscribe(user))
{
return(Unauthorized("Request is not open!"));
}
await _requestRepository.UpdateRequest(request);
await _userRepository.UpdateUser(user);
return(Ok("Successfully subscribed!"));
}
public List <string> GetSubscriptionTagsByUser(string user)
{
if (_subscriptions == null)
{
return(null);
}
SubscribeDTO retSub = _subscriptions.Find(delegate(SubscribeDTO dto) {
return(dto.User == user);
});
return(retSub.Tags);
}
public SubscribeDTO GetSubscriptionByUser(string user)
{
if (_subscriptions == null)
{
return(null);
}
SubscribeDTO retSub = _subscriptions.Find(delegate(SubscribeDTO dto) {
return(dto.User == user);
});
return(retSub);
}
public async Task UnsubscribeAsync([Remainder] string tag)
{
if (!await Helper.VerifyMod(Context))
{
return;
}
var embed = new EmbedBuilder();
embed.WithTitle("🚩");
embed.WithColor(Helper.GetRandomColor());
string userName = Context.User.Username;
SubscribeDTO subDTO = SubscriptionManager.TheSubscriptionManager.GetSubscriptionByUser(userName);
if (null == subDTO)
{
// nothing to unsubscribe... no record of any previous subscription activity
embed.AddField(Constants.TITLE_UNSUBSCRIBE, Constants.ERROR_NO_SUBSCRIPTIONS);
await ReplyAsync(string.Empty, false, embed);
}
else
{
if (tag.ToLower() == "all")
{
subDTO.Tags.Clear();
embed.AddField(Constants.TITLE_UNSUBSCRIBE, Constants.INFO_UNSUBSCRIBE_ALL_SUCCESS);
await ReplyAsync(string.Empty, false, embed);
}
else
{
if (subDTO.Tags.Contains(tag.ToLower()))
{
subDTO.Tags.Remove(tag.ToLower());
embed.AddField(Constants.TITLE_UNSUBSCRIBE,
string.Format(Constants.INFO_UNSUBSCRIBE_SUCCESS, tag));
await ReplyAsync(string.Empty, false, embed);
}
else
{
embed.AddField(Constants.TITLE_UNSUBSCRIBE,
string.Format(Constants.INFO_NOT_SUBSCRIBED, tag.ToLower()));
await ReplyAsync(string.Empty, false, embed);
}
// update subscription preferences
SubscriptionManager.TheSubscriptionManager.UpdateSubscription(subDTO);
}
}
}
public bool deleteSubscribe(SubscribeDTO s)
{
try
{
Db.Deleteable <SUBSCRIBE>().Where(new SUBSCRIBE()
{
CUSTOMER_ID = s._customer_id, MEDICINE_ID = s._medicine_id
}).ExecuteCommand();
return(true);
}
catch (Exception e)
{
return(false);
}
}
public bool insertSubsribe(SubscribeDTO s)
{
try
{
SUBSCRIBE temp = new SUBSCRIBE();
temp.CUSTOMER_ID = s._customer_id;
temp.MEDICINE_ID = s._medicine_id;
Db.Insertable <SUBSCRIBE>(temp).ExecuteCommand();
return(true);
}
catch (Exception e)
{
return(false);
}
}
public void RemoveSubscriptionsByUser(string user)
{
if (_subscriptions == null)
{
return;
}
SubscribeDTO retSub = GetSubscriptionByUser(user);
if (null != retSub)
{
_subscriptions.Remove(retSub);
SaveSubscriptions();
}
}
public void UpdateSubscription(SubscribeDTO sub)
{
if (null != sub)
{
_subscriptions.Remove(sub);
}
SubscribeDTO newSub = new SubscribeDTO();
newSub.Id = sub.Id;
newSub.User = sub.User;
newSub.Tags = sub.Tags;
_subscriptions.Add(newSub);
SaveSubscriptions();
}
public JsonResult Subscribe(SubscribeDTO obj)
{
try
{
if (!ModelState.IsValid)
{
return(Json(ModelState));
}
if (db.Members.Count(t => t.Email.ToLower() == obj.Email.ToLower()) == 0)
{
Member m = new Member()
{
CreateDate = DateTime.Now,
Email = obj.Email,
FirstName = obj.Name,
Newsletter = true,
Password = "",
Status = MemberStatus.Inactive,
UserType = MemberTypeType.Reader
};
db.Members.Add(m);
db.SaveChanges();
string emessage = System.Web.Hosting.HostingEnvironment.MapPath("~/ActivationEmail.html");
string subject = "Activate Your Rudra Sofftech Subscription";
emessage = emessage.Replace("[name]", obj.Name);
emessage = emessage.Replace("[activateurl]", string.Format("https://www.rudrasofttech.com/activateemail?mail={0}", obj.Email));
emessage = emessage.Replace(System.Environment.NewLine, "<br/>");
EmailManager manager = new EmailManager(db);
manager.SendMail(Utility.NewsletterEmail, obj.Email, Utility.SiteName, obj.Name, emessage, subject, EmailMessageType.Activation, EmailMessageType.Activation.ToString());
}
else
{
Member m = db.Members.FirstOrDefault(t => t.Email.ToLower() == obj.Email.ToLower());
m.Status = MemberStatus.Active;
m.ModifyDate = DateTime.Now;
db.SaveChanges();
}
return(Json(new { status = "success", message = "" }));
}
catch (Exception ex)
{
return(Json(new { status = "error", message = "Unable to subscribe. " + ex.Message }));
}
}
public bool hasSubscribed(SubscribeDTO t)
{
try
{
var s = Db.Queryable <SUBSCRIBE>().Where(su => su.CUSTOMER_ID == t._customer_id && su.MEDICINE_ID == t._medicine_id).First();
if (s != null)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
return(false);
}
}
public IActionResult hasSubscribed([FromForm] SubscribeDTO s)
{
SubscribeManager subscribeManager = new SubscribeManager();
var flag = subscribeManager.hasSubscribed(s);
if (flag == true)
{
return(Ok(new JsonCreate()
{
message = Utils.ConstMessage.GET_SUCCESS, data = true
}));
}
else
{
return(Ok(new JsonCreate()
{
message = Utils.ConstMessage.GET_SUCCESS, data = false
}));
}
}
public IActionResult insertSubsribe([FromForm] SubscribeDTO subscribeDTO)
{
SubscribeManager subscribeManager = new SubscribeManager();
bool flag = subscribeManager.insertSubsribe(subscribeDTO);
if (flag == true)
{
return(Ok(new JsonCreate()
{
message = Utils.ConstMessage.INSERT_SUCCESS, data = true
}));
}
else
{
return(Ok(new JsonCreate()
{
message = Utils.ConstMessage.CONFILICT, data = false
}));
}
}
public IActionResult deleteSubscribe([FromForm] SubscribeDTO s)
{
SubscribeManager subscribeManager = new SubscribeManager();
var flag = subscribeManager.deleteSubscribe(s);
if (flag == true)
{
return(Ok(new JsonCreate()
{
message = Utils.ConstMessage.UPDATE_SUCCESS, data = true
}));
}
else
{
return(Ok(new JsonCreate()
{
message = Utils.ConstMessage.UPDATE_FAIL, data = false
}));
}
}
public async Task SubscribeAsync([Remainder] string tag)
{
if (!await Helper.VerifyMod(Context))
{
return;
}
var embed = new EmbedBuilder();
embed.WithTitle(Constants.EMOJI_GO);
embed.WithColor(Helper.GetRandomColor());
string msg = string.Empty;
string userName = Context.User.Username;
SubscribeDTO subDTO = SubscriptionManager.TheSubscriptionManager.GetSubscriptionByUser(userName);
if (tag.ToLower() == "list")
{
if (subDTO == null)
{
embed.AddField(Constants.TITLE_SUBSCRIBE, Constants.ERROR_NO_SUBSCRIPTIONS);
}
else
{
string list = GetSubscriptionsList(subDTO.Tags);
embed.AddField(Constants.TITLE_SUBSCRIBE,
string.Format(Constants.INFO_CURRENT_SUBSCRIPTIONS, list));
}
await ReplyAsync(string.Empty, false, embed);
return;
}
// if there are no subscriptions for the user, add one!
if (subDTO == null)
{
List <string> tags = new List <string>();
tags.Add(tag.ToLower());
subDTO = new SubscribeDTO()
{
Id = Context.User.Id,
Tags = tags,
User = userName
};
}
else
{
// there are already subscriptions, lets not add duplicates
if (!subDTO.Tags.Contains(tag))
{
subDTO.Tags.Add(tag.ToLower());
embed.AddField(Constants.TITLE_SUBSCRIBE,
string.Format(Constants.INFO_SUBSCRIPTION_SUCCESS, tag.ToLower()));
await ReplyAsync(string.Empty, false, embed);
}
else
{
// acknowledge that the subscription already exists
embed.AddField(Constants.TITLE_SUBSCRIBE,
string.Format(Constants.INFO_TAG_EXISTS, tag.ToLower()));
await ReplyAsync(string.Empty, false, embed);
}
}
// finally, save any changes!
SubscriptionManager.TheSubscriptionManager.UpdateSubscription(subDTO);
}
