public bool SendDraft(Controller controller, int draftId = -1)
{
string loggedUserName = UserSession.GetLoggedUserName();
SMS smsData = null;
DraftUser draftUser = db.DraftUser.SingleOrDefault(x => x.DraftId == draftId &&
x.UserName == loggedUserName);
smsData = new SMS
{
Content = draftUser.Draft.Content,
DestinationNumber = draftUser.Draft.DestinationNumber,
ScheduleTime = draftUser.Draft.ScheduleTime,
Scheduled = draftUser.Draft.Scheduled,
};
smsData.TimeStamp = DateTime.Now;
if (smsData.DestinationNumber == null)
{
return(false);
}
db.Drafts.Remove(draftUser.Draft);
db.DraftUser.Remove(draftUser);
return(Send(controller, smsData));
}
public static DraftUser AuthenticateRequest(HttpRequestBase request, int?userId = null)
{
DraftUser toRet = null;
if (request.Cookies["DraftUser"] == null || String.IsNullOrWhiteSpace(request.Cookies["DraftUser"].Value))
{
throw new DraftAuthenticationException("No session");
}
try
{
String base64Encoded = DraftAuthentication.UnescapeToken(request.Cookies["DraftUser"].Value);
byte[] bytes = Convert.FromBase64String(base64Encoded);
byte[] decryptedBytes = MachineKey.Unprotect(bytes);
String final = Encoding.Unicode.GetString(decryptedBytes);
toRet = new JavaScriptSerializer().Deserialize <DraftUser>(final);
}
catch (Exception ex)
{
throw new DraftAuthenticationException("Authentication Failed", ex);
}
if (toRet.Expires < DateTime.UtcNow)
{
throw new DraftAuthenticationException(toRet.Username, toRet.Expires, "Authentication Expired");
}
if (userId.HasValue && toRet.ID != userId.Value)
{
throw new DraftAuthenticationException("Unauthorized User");
}
return(toRet);
}
public bool SaveDraft(Controller controller, SMS smsInput)
{
Draft draft = new Draft
{
Content = smsInput.Content,
DestinationNumber = smsInput.DestinationNumber,
Scheduled = smsInput.Scheduled
};
if (draft.Scheduled)
{
draft.ScheduleTime = smsInput.ScheduleTime;
}
else
{
draft.ScheduleTime = DateTime.Now;
}
db.Drafts.Add(draft);
db.SaveChanges();
DraftUser draftUser = new DraftUser
{
UserName = UserSession.GetLoggedUserName(),
DraftId = draft.DraftId
};
db.DraftUser.Add(draftUser);
db.SaveChanges();
return(true);
}
public List <DraftPickStatusObj> Post(DraftPickStatusObj next)
{
DraftUser user = DraftAuthentication.AuthenticateRequest(Request);
if (!next.Player.HasValue)
{
throw new HttpStatusException(HttpStatusCode.NotFound, "The player you entered is invalid or does not exists");
}
else
{
PickResult result = dataSource.SubmitPick(user.ID, next.Player.Value);
if (result != PickResult.Success)
{
switch (result)
{
case PickResult.AlreadyPicked:
throw new HttpStatusException(HttpStatusCode.MethodNotAllowed, "That player has already been chosen");
case PickResult.InvalidPlayer:
throw new HttpStatusException(HttpStatusCode.NotFound, "The player you entered is invalid or does not exist");
case PickResult.NotTurn:
throw new HttpStatusException(HttpStatusCode.Forbidden, "It's not your turn to pick");
case PickResult.InvalidPosition:
throw new HttpStatusException(HttpStatusCode.Forbidden, "Players at that position cannot be drafted");
case PickResult.PositionMax:
throw new HttpStatusException(HttpStatusCode.Forbidden, "Position Max - You cannot draft any more players at that position");
}
}
}
return(GetDraftPicks());
}
public ActionResult Index(LoginUser loginUser)
{
try
{
DraftUser user = DraftAuthentication.AuthenticateCredentials(loginUser.Username, loginUser.Password, HttpContext.Response);
return(RedirectToAction("Index", "Home"));
}
catch (DraftAuthenticationException exc)
{
LoginUser retry = new LoginUser()
{
Username = loginUser.Username
};
if (!String.IsNullOrWhiteSpace(exc.Username))
{
retry.LoginMessage = exc.Username + " " + exc.Message + " " + exc.Expired.ToLongDateString() + " @ " + exc.Expired.ToLongTimeString();
}
else
{
retry.LoginMessage = exc.Message;
}
retry.ErrorMessage = exc.Message;
return(View(retry));
}
}
public DraftUser GetUser(String username, String password)
{
DraftUser toRet = null;
var query = from t in db.Usernames
where t.Username1 == username &&
t.User.Password == password
select t;
if (query.Count() > 0)
{
Username currUsername = query.First();
var orderQuery = from t in db.DraftOrders
where t.SeasonID == Settings.DraftSeasonID &&
t.UserID == currUsername.UserID
select t;
int order = -1;
if (orderQuery.Count() > 0)
{
order = orderQuery.First().Order;
}
toRet = new DraftUser(query.First(), order);
}
return(toRet);
}
public List <DraftMoveObj> Get()
{
DraftUser user = DraftAuthentication.AuthenticateRequest(Request, 1);
List <DraftMoveObj> onClock = dataSource.FindOnTheClock();
return(onClock);
}
public UserStatusObj Get()
{
DraftUser user = DraftAuthentication.AuthenticateRequest(Request);
UserStatusObj toRet = dataSource.GetStatus(user.ID);
return(toRet);
}
public List <ChatObj> Get()
{
DraftUser user = DraftAuthentication.AuthenticateRequest(Request);
List <ChatObj> chatData = this.dataSource.GetChatData();
return(chatData);
}
public DraftStatusObj Get()
{
DraftUser user = DraftAuthentication.AuthenticateRequest(Request, 1);
DraftStatusObj status = this.dataSource.GetDraftStatusObj();
return(status);
}
public UserStatusObj Post(UserStatusObj next)
{
DraftUser user = DraftAuthentication.AuthenticateRequest(Request);
UserStatusObj toRet = this.dataSource.UpdateStatus(next);
return(toRet);
}
public ActionResult Index()
{
try
{
DraftUser user = DraftAuthentication.AuthenticateRequest(HttpContext.Request);
return(RedirectToAction("Index", "Home"));
}
catch (DraftAuthenticationException)
{
return(View(new LoginUser()));
}
}
public DraftMoveObj Put(OnClockUpdateObj update)
{
DraftUser user = DraftAuthentication.AuthenticateRequest(Request, 1);
DraftMoveObj toRet = dataSource.UpdateLastOnTheClock(update);
if (toRet == null)
{
throw new HttpStatusException(HttpStatusCode.NotFound, "Unable to find pick to update");
}
return(toRet);
}
private List <DraftPickStatusObj> GetDraftPicks()
{
DraftUser user = DraftAuthentication.AuthenticateRequest(Request);
List <DraftPickStatusObj> toRet = new List <DraftPickStatusObj>();
List <DraftMoveObj> onTheClock = new List <DraftMoveObj>();
Dictionary <QuickPick, DraftMoveObj> draftData = dataSource.QueryDraftData(out onTheClock);
DraftPickStatusObj onClockPick = null;
DraftMoveObj lastOnClockMoveObj = null;
for (QuickPick index = new QuickPick(); index.Round <= BallersDraftObj.Settings.RoundsPerDraft; index.Round++)
{
for (index.Pick = 1; index.Pick <= BallersDraftObj.Settings.TeamsPerDraft; index.Pick++)
{
DraftMoveObj nextMove = draftData[index];
toRet.Add(new DraftPickStatusObj(BallersDraftObj.Settings.TeamsPerDraft)
{
Round = nextMove.Round,
Pick = nextMove.Pick,
Team = nextMove.UserID,
Player = nextMove.PlayerID,
Type = nextMove.TypeInt
});
}
}
foreach (DraftMoveObj currMove in onTheClock)
{
lastOnClockMoveObj = currMove;
onClockPick = new DraftPickStatusObj(BallersDraftObj.Settings.TeamsPerDraft)
{
Round = currMove.Round,
Pick = currMove.Pick,
Team = currMove.UserID,
Type = currMove.TypeInt
};
toRet[onClockPick.TotalPick - 1] = onClockPick;
}
if (lastOnClockMoveObj != null)
{
TimeSpan timeLeft = TimeSpan.FromSeconds(BallersDraftObj.Settings.SecondsPerPick) - (DateTime.Now - lastOnClockMoveObj.Time);
if (timeLeft < TimeSpan.FromTicks(0))
{
timeLeft = TimeSpan.FromTicks(0);
}
onClockPick.TimeLeft = (int)timeLeft.TotalSeconds;
}
return(toRet);
}
public ActionResult Index()
{
DraftViewModel model = null;
try {
DraftUser user = DraftAuthentication.AuthenticateRequest(HttpContext.Request);
model = new DraftViewModel(user);
} catch (DraftAuthenticationException)
{
return(RedirectToAction("Index", "Login"));
}
return(View(model));
}
public bool UpdateDraft(Controller controller, int draftId, Draft draft)
{
string loggedUserName = UserSession.GetLoggedUserName();
DraftUser draftUser = (
from userDraft in db.DraftUser
where userDraft.UserName == loggedUserName && userDraft.DraftId == draftId
select userDraft
).ToList().First();
draftUser.Draft = draft;
db.SaveChanges();
return(true);
}
public bool SaveDraft(Controller controller, SMS smsInput)
{
Draft draft = ConvertToDraft(smsInput);
db.Drafts.Add(draft);
db.SaveChanges();
DraftUser draftUser = new DraftUser
{
UserName = UserSession.GetLoggedUserName(),
DraftId = draft.DraftId
};
db.DraftUser.Add(draftUser);
db.SaveChanges();
return(true);
}
public List <ChatObj> Post(ChatObj next)
{
DraftUser user = DraftAuthentication.AuthenticateRequest(Request);
String text = next.Text;
if (!String.IsNullOrWhiteSpace(text))
{
this.dataSource.SubmitChat(new ChatObj()
{
Text = text.Trim(),
UserID = user.ID,
Date = DateTime.Now
});
}
List <ChatObj> chatData = this.dataSource.GetChatData();
return(chatData);
}
public static DraftUser AuthenticateCredentials(String username, String password, HttpResponseBase response)
{
if (String.IsNullOrWhiteSpace(username) || String.IsNullOrWhiteSpace(password))
{
throw new DraftAuthenticationException("Invalid credentials");
}
DraftUser user = DraftObj.GetUser(username, password);
if (user == null)
{
throw new DraftAuthenticationException("Invalid username or password");
}
if (response != null)
{
String rawString = new JavaScriptSerializer().Serialize(user);
byte[] rawBytes = Encoding.Unicode.GetBytes(rawString);
byte[] encryptedBytes = MachineKey.Protect(rawBytes);
response.Cookies["DraftUser"].Value = DraftAuthentication.EscapeToken(Convert.ToBase64String(encryptedBytes));
response.Cookies["DraftUser"].Expires = DateTime.Now.AddDays(1);
}
return(user);
}
public AdminViewModel(DraftUser user)
{
_UserData = user;
}
public DraftStatusObj Post(DraftStatusObj newStatus)
{
DraftUser user = DraftAuthentication.AuthenticateRequest(Request, 1);
return(this.dataSource.SetNextDraftStatusObj(newStatus));
}
public AdminViewModel(DraftUser user)
{
_UserData = user;
}
