public async Task <IActionResult> PutEventDay(int id, EventDay eventDay)
{
if (id != eventDay.Id)
{
return(BadRequest());
}
_context.Entry(eventDay).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EventDayExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult> EditPost(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EventDay eventDay = await db.EventDays.FindAsync(id);
if (eventDay == null)
{
return(HttpNotFound());
}
if (TryUpdateModel(eventDay, "", new string[] { "Name", "EventDate" }))
{
try
{
await db.SaveChangesAsync();
return(RedirectToAction("Details", new { id = eventDay.ID }));
}
catch (DataException /* dex */)
{
// Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
}
return(View(eventDay));
}
private static void ChooseEventToBet(EventDay day)
{
var wlLeft = new WLLeft(driver);
SwitchFrame(Frame.LeftPanel);
switch (day)
{
case EventDay.Yesterday:
ElementVerify.Visable(driver, wlLeft.InplayTab).ClickOnIt("InplayTab");
ElementVerify.Visable(driver, wlLeft.InplayCheckboxAll).ClickOnIt("All Competition Checkbox");
break;
case EventDay.Today:
ElementVerify.Visable(driver, wlLeft.TodayTab).ClickOnIt("TodayTab");
ElementVerify.Visable(driver, wlLeft.Today1stAHOU).ClickOnIt("Today's First sport AHOU");
break;
case EventDay.Tomorrow:
ElementVerify.Visable(driver, wlLeft.TomorrowTab).ClickOnIt("TomorrowTab");
ElementVerify.Visable(driver, wlLeft.Tomorrow1stAHOU).ClickOnIt("Tomorrow's First sport AHOU");
break;
}
PlaceBet(day);
}
public void UpdateItem(string id)
{
if (!master.isAdmin)
{
master.ShowErrorMessage("Not authorized.");
return;
}
EventDay item = null;
item = dbContext.EventDays.Find(int.Parse(id));
if (item == null)
{
ModelState.AddModelError("", String.Format("Item with id {0} was not found", id));
return;
}
TryUpdateModel(item);
if (ModelState.IsValid)
{
dbContext.Entry(item).State = EntityState.Modified;
dbContext.SaveChanges();
master.ShowSuccessMessage("Item updated");
this.DataBind();
}
}
public async Task <ActionResult <EventDay> > PostEventDay(EventDay eventDay)
{
_context.EventDay.Add(eventDay);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEventDay", new { id = eventDay.Id }, eventDay));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
EventDay eventDay = await db.EventDays.FindAsync(id);
db.EventDays.Remove(eventDay);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public IActionResult ShowEventsForDate(DateTime date)
{
var eventDay = new EventDay
{
Events = _eventService.GetAllEventsForCurrentUser()
.Where(e => Utilities.DateTimeExtensions.IsInDateRange(date, e.EventStart, e.EventEnd))
.ToList(),
Date = date
};
return(View("Index", eventDay));
}
public IActionResult ShowEvents(int daysOffset)
{
var startDate = DateTime.Today.AddDays(daysOffset - 1);
var endDate = DateTime.Today.AddDays(daysOffset + 1);
var eventDay = new EventDay
{
Events = _eventService.GetAllEventsForCurrentUser()
.Where(e => e.EventStart > startDate && e.EventEnd < endDate)
.ToList(),
Date = DateTime.Now.AddDays(daysOffset)
};
return(View("Index", eventDay));
}
private static void PlaceBet(EventDay day)
{
IAlert alert;
var wlRight = new WLRight(driver);
var wlLeft = new WLLeft(driver);
string eventid = String.Empty;
switch (day)
{
case EventDay.Yesterday:
eventid = "709369";
break;
case EventDay.Today:
eventid = "";
break;
case EventDay.Tomorrow:
eventid = "";
break;
}
By MoreBetButton = By.Id("mbb_" + eventid + "");
By MoreBetExpand = By.XPath("//*[@id='eventContainer'][@eid='" + eventid + "']");
By Odds = By.XPath("//*[@id='eventContainer']/div[2]/table/tbody/tr[2]/td[3]/div/a");
// Add selection to bet slip
SwitchFrame(Frame.RightPanel);
Thread.Sleep(1000);
ElementVerify.PresenceAll(driver, MoreBetButton).ClickOnIt("Morebet");
if (ElementVerify.Visable(driver, MoreBetExpand) != null)
{
ElementVerify.Visable(driver, Odds).ClickOnIt("Odds");
}
// Swtich to Bet Slip
SwitchFrame(Frame.LeftPanel);
ElementVerify.Visable(driver, wlLeft.BetSlipStake).EnterText("Stake", "20000");
ElementVerify.Visable(driver, wlLeft.PlaceBetButton).ClickOnIt("PlaceBetButton");
alert = driver.SwitchTo().Alert();
alert.Accept();
if (ElementVerify.Visable(driver, wlLeft.BetConfirm) != null)
{
WriteConsole.Green("Place bet successfully");
}
//string[] wagers = ElementVerify.Visable(driver, wlLeft.WagerNumber).Text;
}
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EventDay eventDay = await db.EventDays.FindAsync(id);
if (eventDay == null)
{
return(HttpNotFound());
}
ViewBag.EventDayID = eventDay.ID;
return(View(eventDay));
}
private void initCalendar()
{
removeUselessData();
List <EventDay> events = new List <EventDay>();
foreach (KeyValuePair <string, List <HMEvent> > entry in mDict)
{
Calendar calendar = Calendar.GetInstance(new Locale("en_AU"));
SimpleDateFormat sdf = new SimpleDateFormat("MM-dd-yyyy", new Locale("en_AU"));
calendar.Time = sdf.Parse(entry.Key);
EventDay eventDay = new EventDay(calendar, Resource.Mipmap.cleaning);
events.Add(eventDay);
}
mCalendarView.SetEvents(events);
}
private void SeedEventDays(VeloEventsManagerDbContext context)
{
if (context.EventDays.Any())
{
return;
}
var routes = context.Routes.ToList();
var trips = context.Events.ToList();
random = new Random();
for (int i = 0; i < 100; i++)
{
var date = DateTime.Now.AddDays(i);
var startTime = DateTime.Now.AddDays(i).AddHours(i);
var endTime = DateTime.Now.AddDays(i).AddHours(i + 5);
var mainRoute = routes[random.Next(0, routes.Count)];
var trip = trips[random.Next(0, trips.Count)];
var eventDay = new EventDay()
{
Description = $"Test description: Day {i % 10}. Long day...",
Date = date,
StartTime = startTime,
EndTime = endTime,
MainRoute = mainRoute,
Event = trip
};
// some optional routes
if (i % 2 == 0)
{
for (int j = 0; j < 3; j++)
{
var currentOptionalRoute = routes[random.Next(0, routes.Count)];
eventDay.OptionalRoutes.Add(currentOptionalRoute);
}
}
context.EventDays.Add(eventDay);
}
context.SaveChanges();
}
public async Task <ActionResult> Create([Bind(Include = "Name,EventDate")] EventDay eventDay)
{
try
{
if (ModelState.IsValid)
{
eventDay.CreatedByID = User.Identity.GetId();
db.EventDays.Add(eventDay);
await db.SaveChangesAsync();
return(RedirectToAction("Details", new { id = eventDay.ID }));
}
}
catch (DataException /* dex */)
{
// Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return(View(eventDay));
}
public async Task <IEnumerable <EventDay> > GetActivitiesByDate()
{
List <EventDay> dates = new List <EventDay>();
var query = from activity in await GetActivities()
group activity by activity.Start.Date into grp
orderby grp.Key
select new { GroupName = grp.Key, Items = grp };
foreach (var grp in query)
{
EventDay eventDay = new EventDay();
eventDay.Date = grp.GroupName;
foreach (var item in grp.Items)
{
eventDay.Add(item);
}
dates.Add(eventDay);
}
return(dates);
}
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EventDay eventDay = await db.EventDays.FindAsync(id);
if (eventDay == null)
{
return(HttpNotFound());
}
ViewBag.EventDayID = eventDay.ID;
var model = new EventDayViewModel
{
ID = eventDay.ID,
CreatedBy = eventDay.CreatedBy?.FullName,
Name = eventDay.Name,
EventDate = eventDay.EventDate,
Total = eventDay.Orders.Sum(o => o.OrderItems.Sum(i => i.Quantity * i.UnitPrice) - o.Vouchers)
};
return(View(model));
}
public async Task<IEnumerable<EventDay>> GetActivitiesByDate() {
List<EventDay> dates = new List<EventDay>();
var query = from activity in await GetActivities()
group activity by activity.Start.Date into grp
orderby grp.Key
select new { GroupName = grp.Key, Items = grp };
foreach (var grp in query) {
EventDay eventDay = new EventDay();
eventDay.Date = grp.GroupName;
foreach (var item in grp.Items) {
eventDay.Add(item);
}
dates.Add(eventDay);
}
return dates;
}
public EventDayViewModel(EventDay day)
{
this.EventDay = day;
this.MapViewModel = new MapViewModel(day.BoothMap);
}
public async Task Add(
[Help("channel", "The targeted text channel")]
IMessageChannel channel,
[Help("day", "Days separated by a comma", "Possible values: %values%")]
EventDay day,
[Help("time", "Formatted time span in UTC", "Examples: '19:30~20:00' or '19:30~20:00+01:00' for UTC+1h")]
string timeMessage,
[Help("title", "The event title")]
[Optional] string title,
[Help("header", "The message posted above the embedded event block, can be used for role pings.")]
[Optional] string header,
[Help("message", "The body message of the event, this accepts multi-lined strings as well as markdown text.")]
[Multiword] string message
)
{
if (!Permissions.IsAdministratorOrBotOwner(Context))
{
await Context.ApplyResultReaction(CommandResult.FailedUserPermission).ConfigureAwait(false);
return;
}
string timeStringBegin = "", timeStringEnd = "", timeStringOffset = "", offsetSign = "+";
var regex = Globals.RegularExpression.TimeMessage;
var match = regex.Match(timeMessage);
foreach (var groupName in regex.GetGroupNames())
{
var groupValue = match.Groups[groupName].Value;
if (groupName == "time1")
{
timeStringBegin = groupValue;
}
else if (groupName == "time2")
{
timeStringEnd = groupValue;
}
else if (groupName == "sign")
{
offsetSign = groupValue;
}
else if (groupName == "offset")
{
timeStringOffset = groupValue;
}
}
// Parse offset
if (!TimeSpan.TryParse(timeStringOffset, out TimeSpan timeOffset))
{
timeOffset = new TimeSpan(0, 0, 0);
}
if (offsetSign == "-")
{
timeOffset = -timeOffset;
}
// Parse time spans
if (!TimeSpan.TryParse(timeStringBegin, out TimeSpan timeBegin))
{
await Context.ApplyResultReaction(CommandResult.InvalidParameters).ConfigureAwait(false);
return;
}
TimeSpan?timeEnd = null;
if (TimeSpan.TryParse(timeStringEnd, out TimeSpan timeEndValue))
{
timeEnd = timeEndValue;
}
// Everything is OK, add it to the database
Event @event = null;
await Ditto.Database.WriteAsync((uow) =>
{
@event = uow.Events.Add(new Event()
{
Guild = Context.Guild,
Channel = channel ?? Context.Channel,
Creator = Context.User,
CreatorName = Context.NicknameAndGlobalUsername,
Days = (Day)day,
Title = title,
MessageHeader = header,
MessageBody = message,
MessageFooter = null,
TimeBegin = timeBegin,
TimeEnd = timeEnd,
TimeCountdown = null,
TimeOffset = timeOffset,
LastRun = DateTime.MinValue
});
});
if (@event == null)
{
// Unexpected error
await Context.ApplyResultReaction(CommandResult.Failed).ConfigureAwait(false);
await Context.EmbedAsync("An unexpected error occurred, please try again.", ContextMessageOption.ReplyWithError).ConfigureAwait(false);
}
else
{
_events.TryAdd(@event.Id, @event);
await Context.ApplyResultReaction(CommandResult.Success).ConfigureAwait(false);
}
}
public Task Add(EventDay day, string timeMessage, [Optional] string title, [Optional] string header, [Multiword] string message) => Add(null, day, timeMessage, title, header, message);
public async Task <int> Insert(EventDay eventDay)
{
_eventDayRepository.Create(eventDay);
return(await Context.SaveChangesAsync());
}
public async Task <int> Update(EventDay eventDay)
{
return(await Context.SaveChangesAsync());
}
public async Task <ActionResultResponse <string> > Insert(string eventId, string creatorId, string creatorFullName, string creatorAvatar, EventDayMeta eventDayMeta)
{
var infoEvent = await _eventRepository.GetInfo(eventId);
if (infoEvent == null)
{
return(new ActionResultResponse <string>(-1, _websiteEventResourceService.GetString("Event does not exists.")));
}
if (infoEvent.StartDate.HasValue && infoEvent.EndDate.HasValue)
{
if (DateTime.Compare(eventDayMeta.EventDate, infoEvent.StartDate.Value) < 0)
{
return(new ActionResultResponse <string>(-2, _websiteEventResourceService.GetString("Event day smaller than start time.")));
}
if (DateTime.Compare(eventDayMeta.EventDate, infoEvent.EndDate.Value) > 0)
{
return(new ActionResultResponse <string>(-3, _websiteEventResourceService.GetString("Event day greater than end time.")));
}
}
if (eventDayMeta.StartHour.HasValue)
{
if ((int)(eventDayMeta.StartHour.Value) < 0 || (int)(eventDayMeta.StartHour.Value) > 24)
{
return(new ActionResultResponse <string>(-4, _websiteEventResourceService.GetString("Start hour invalid input.")));
}
}
if (eventDayMeta.EndHour.HasValue)
{
if ((int)(eventDayMeta.EndHour.Value) < 0 || (int)(eventDayMeta.EndHour.Value) > 24)
{
return(new ActionResultResponse <string>(-5, _websiteEventResourceService.GetString("End hour invalid input.")));
}
}
if (eventDayMeta.StartMinute.HasValue)
{
if ((int)(eventDayMeta.StartMinute.Value) < 0 || (int)(eventDayMeta.StartMinute.Value) > 60)
{
return(new ActionResultResponse <string>(-6, _websiteEventResourceService.GetString("Start minute invalid input.")));
}
}
if (eventDayMeta.EndMinute.HasValue)
{
if ((int)(eventDayMeta.EndMinute.Value) < 0 || (int)(eventDayMeta.EndMinute.Value) > 60)
{
return(new ActionResultResponse <string>(-7, _websiteEventResourceService.GetString("End minute invalid input.")));
}
}
var eventDayId = Guid.NewGuid().ToString();
var eventDay = new EventDay
{
Id = eventDayId,
ConcurrencyStamp = eventDayId,
IsActive = eventDayMeta.IsActive,
StartHour = eventDayMeta.StartHour,
StartMinute = eventDayMeta.StartMinute,
EndHour = eventDayMeta.EndHour,
EndMinute = eventDayMeta.EndMinute,
LimitedUsers = eventDayMeta.LimitedUsers,
StaffOnly = eventDayMeta.StaffOnly,
EventDate = eventDayMeta.EventDate,
IsAllowAccompanyPerson = eventDayMeta.IsAllowAccompanyPerson,
LimitedAccompanyPersons = eventDayMeta.LimitedAccompanyPersons,
EventId = eventId,
CreatorId = creatorId,
CreatorFullName = creatorFullName,
CreatorAvatar = creatorAvatar
};
var result = await _eventDayRepository.Insert(eventDay);
if (result <= 0)
{
return(new ActionResultResponse <string>(result,
_sharedResourceService.GetString(ErrorMessage.SomethingWentWrong)));
}
#region insert Translation.
if (eventDayMeta.EventDayTranslations.Count > 0)
{
var resultInsertTranslation = await InsertEventDayTranslation();
if (resultInsertTranslation.Code <= 0)
{
return(resultInsertTranslation);
}
}
#endregion
return(new ActionResultResponse <string>(1, _websiteEventResourceService.GetString("Add new event day successful."),
string.Empty, eventId));
#region Local functions
async Task <ActionResultResponse <string> > InsertEventDayTranslation()
{
var eventDayTranslations = new List <EventDayTranslation>();
foreach (var eventDayTranslation in eventDayMeta.EventDayTranslations)
{
//// Check name exists.
//var isNameExists = await _eventDayTranslationRepository.CheckExists(eventId,
// eventDayTranslation.LanguageId, eventDayTranslation.Name);
// if (isNameExists)
// {
// await RollbackInsertEventDay();
// return new ActionResultResponse<string>(-2,
// _websiteEventResourceService.GetString("Event name: \"{0}\" already exists.",
// eventDayTranslation.Name));
// }
var eventDayTranslationInsert = new EventDayTranslation
{
EventDayId = eventDayId,
LanguageId = eventDayTranslation.LanguageId.Trim(),
Name = eventDayTranslation.Name.Trim(),
Description = eventDayTranslation.Description?.Trim(),
Address = eventDayTranslation.Address?.Trim()
};
eventDayTranslations.Add(eventDayTranslationInsert);
}
var resultTranslation = await _eventDayTranslationRepository.Inserts(eventDayTranslations);
if (resultTranslation > 0)
{
return(new ActionResultResponse <string>(resultTranslation,
_websiteEventResourceService.GetString("Add new event day translation successful.")));
}
await RollbackInsertEventDayTranslation();
await RollbackInsertEventDay();
return(new ActionResultResponse <string>(-4,
_websiteEventResourceService.GetString("Can not insert event day translation. Please contact with administrator.")));
}
async Task RollbackInsertEventDay()
{
await _eventDayRepository.ForceDelete(eventId);
}
async Task RollbackInsertEventDayTranslation()
{
await _eventDayTranslationRepository.Delete(eventId);
}
#endregion Local functions
}
