public static bool InsertTask(ITaskGroup group, DailyTask task)
{
lock (_manager_lock)
{
if (!task.Title.IsNullOrWhiteSpace() || (task.TaskItems != null && task.TaskItems.Count > 0))
{
if (TaskGroups.SingleOrDefault(p => p.GroupId.Equals(group.GroupId)) == null)
{
AddGroup(group);
}
group.DailyTasks.Insert(0, task);
task.GroupId = group.GroupId;
OnTaskListChanged(task, TaskChangedType.Insert);
return(true);
}
return(false);
}
}
void Awake()
{
// jsonString = File.ReadAllText(Application.dataPath + "/DailyTask.json");
// jsonData = JsonMapper.ToObject(jsonString);
_taskSize = 0;
TASK_TABLE_MAX = 3;
TASK_NUMBER = 3;
_taskNumber = new int[3] {
0, 1, 2
};
_complete = new float[3] {
0, 0, 0
};
_data = GameManager.Instance.InitializeDailyTask();
_taskNumber = _data._taskNumber;
_complete = _data.Complete;
ShowTask();
}
public static bool RemoveTask(DailyTask task)
{
lock (_manager_lock)
{
try
{
var result = TaskGroups.SingleOrDefault(p => p.GroupId == task.GroupId).DailyTasks.Remove(task);
task.OldGroupId = task.GroupId;
task.GroupId = null;
OnTaskListChanged(task, TaskChangedType.Remove);
return(result);
}
catch
{
return(false);
}
}
}
public void UpdateDailyTask(DailyTask dailyTask)
{
try
{
this.Update(dailyTask);
this.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!DailyTaskExists(dailyTask.DailyTaskId))
{
AddNewTask(dailyTask);
}
else
{
throw;
}
}
}
public static bool AddTask(string taskgroupid, DailyTask task)
{
lock (_manager_lock)
{
if (!task.Title.IsNullOrWhiteSpace() || (task.TaskItems != null && task.TaskItems.Count > 0))
{
var group = GetTaskGroup(taskgroupid);
if (group != null)
{
group.DailyTasks.Add(task);
task.GroupId = group.GroupId;
OnTaskListChanged(task, TaskChangedType.Add);
Debug.WriteLine(group.DailyTasks.Count);
return(true);
}
}
return(false);
}
}
public async Task <ActionResult <DailyTask> > Put(int id, [FromBody] DailyTask dailyTask)
{
//var oldData = await _allTaskMethods.GetDailyTaskByIdAsync(id);
if (id != dailyTask.id)
{
return(NotFound());
}
if (dailyTask != null)
{
_allTaskMethods.updateDailyTask(dailyTask);
if (await _allTaskMethods.SaveChangesAsync())
{
return(Ok());
}
return(BadRequest(dailyTask));
}
return(BadRequest());
}
public async Task <ActionResult> Delete(int id, DailyTask dailyTask)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(BaseUrl);
var response = await client.DeleteAsync($"api/DailyTasks/{id}");
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "Server error try after some time.");
}
}
return(View());
}
private void addTab_Click(object sender, EventArgs e)
{
DailyTask dt = new DailyTask();
using (TaskEditForm editForm = new TaskEditForm(dt))
{
editForm.GlobalStyleManager = this.metroStyleManager;
if (editForm.ShowDialog(this) == System.Windows.Forms.DialogResult.OK)
{
var group = this.metroTabControl.SelectedTab.Tag as ITaskGroup;
if (TaskManager.AddTask(group, dt))
{
var form = AddTaskForm(dt);
this.metroTabControl.SelectedTab.Controls.Add(form);
this.metroTabControl.SelectedTab.ScrollControlIntoView(form);
this.metroStyleManager.Update();
}
}
}
}
public IActionResult Create(DailyTask dailyTask)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(BaseUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var Result = client.PostAsJsonAsync <DailyTask>("api/DailyTasks", dailyTask).Result;
if (Result.IsSuccessStatusCode == true)
{
return(RedirectToAction(nameof(Index)));
}
else
{
return(View());
}
}
}
private int SortDailyByPoint(DailyTask a, DailyTask b)
{
MeiRiMuBiao meiRiMuBiao = DataReader <MeiRiMuBiao> .Get(a.taskId);
MeiRiMuBiao meiRiMuBiao2 = DataReader <MeiRiMuBiao> .Get(b.taskId);
if (meiRiMuBiao == null || meiRiMuBiao2 == null)
{
return(0);
}
if (meiRiMuBiao.priority < meiRiMuBiao2.priority)
{
return(1);
}
if (meiRiMuBiao.priority > meiRiMuBiao2.priority)
{
return(-1);
}
return(0);
}
private void OnGetDailyTaskPrizeRes(short state, GetDailyTaskPrizeRes down = null)
{
if (state != 0)
{
StateManager.Instance.StateShow(state, 0);
return;
}
DailyTask dailyTask = this.mDailyList.Find((DailyTask e) => e.taskId == this.mLastFindTaskId);
if (dailyTask != null)
{
dailyTask.canFindTimes -= this.mLastFindTimes;
if (dailyTask.canFindTimes < 0)
{
dailyTask.canFindTimes = 0;
}
EventDispatcher.Broadcast(EventNames.DailyTaskFindRes);
this.CheckTownDailyTaskPoint();
}
}
public IHttpActionResult PostDailyTask(DailyTask dailyTask)
{
var employeeRole = db.Employees.Where(x => x.EmployeeId == dailyTask.EmployeeRef).Select(x => x.EmployeeRoleRef).FirstOrDefault();
var employeeRate = db.EmployeeRoles.Where(x => x.RoldeId == employeeRole).Select(x => x.Rate).FirstOrDefault();
var allocatedTime = db.TaskDetails.Where(x => x.TaskId == dailyTask.TaskRef).Select(x => x.TaskDuration).FirstOrDefault();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
dailyTask.HourlyRate = employeeRate;
dailyTask.TaskTime = allocatedTime;
db.DailyTasks.Add(dailyTask);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = dailyTask.DailyTaskId }, dailyTask));
}
public TaskForm(Form mdiParent, DailyTask dt)
{
InitializeComponent();
this.DailyTask = dt;
this.ControlBox = false;
this.MdiParent = mdiParent;
this.MouseDown += TaskForm_MouseDown;
this.MouseMove += TaskForm_MouseMove;
this.MouseUp += TaskForm_MouseUp;
this.lb_Title.DataBindings.Add("Text", DailyTask, "Title", true, DataSourceUpdateMode.OnPropertyChanged);
this.lb_Date.DataBindings.Add("Text", DailyTask, "Date", true, DataSourceUpdateMode.OnPropertyChanged);
this.contentPanel.PagePanelDock <CustomLabel>(callBack => { }, false);
ShowTaskContentItem(dt);
PointMenuItem();
}
public async Task IndexShouldReturnViewWithData()
{
// arrange
var mockRepo = new Mock <IRepository <DailyTask> >();
// Moq gives us Mock class
// which can implement interfaces at runtime
// 1. you create the Mock
// 2. you Setup the mock (giving it behavior)
// 3. you give mock.Object to your test subject object
// (4. you can use methods like Verify ot make sure that things were called on the mock object)
mockRepo.Setup(x => x.GetAll())
.ReturnsAsync(new List <DailyTask> {
new DailyTask {
DailyTaskId = 1
}
});
// mockRepo.Setup(x => x.Delete(It.IsAny<int>()))
// mockRepo.Setup(x => x.Delete(It.IsInRange<int>(-99999, 0, Moq.Range.Inclusive)))
// mockRepo.Setup(x => x.Delete(5))
// .ThrowsAsync(new InvalidOperationException());
var controller = new DailyTasksController(mockRepo.Object);
// act
IActionResult result = await controller.Index();
// assert
// ...that the result is a ViewResult
var viewResult = Assert.IsAssignableFrom <ViewResult>(result);
// ...that the model of the view is a List<DailyTask>
var list = Assert.IsAssignableFrom <List <DailyTask> >(viewResult.Model);
// ...that the list has one element with ID 1 (based on the MockRepo's data)
DailyTask dailyTask = Assert.Single(list);
Assert.Equal(1, dailyTask.DailyTaskId);
// we might also test that the correct view was chosen (DailyTasks/Index)
mockRepo.Verify(x => x.GetAll(), Times.Once); // verify that the method was called once
}
public async Task hourly(CommandContext ctx)
{
User DBUser = await Client.DBContext.Users.FirstOrDefaultAsync(x => x.UserId == ctx.Message.Author_Id && x.PlanetId == ctx.Message.Planet_Id);
int minutesleft = (DBUser.LastHourly.AddHours(1).Subtract(DateTime.UtcNow)).Minutes;
if (minutesleft <= 0)
{
// check if the member has a daily task
DailyTask task = await Client.DBContext.DailyTasks.FirstOrDefaultAsync(x => x.MemberId == ctx.Member.Id && x.TaskType == "Hourly Claims");
if (task != null)
{
if (task.Done < task.Goal)
{
task.Done += 1;
if (task.Done == task.Goal)
{
DBUser.Coins += task.Reward;
await Client.DBContext.AddStat("Coins", task.Reward, ctx.Message.Planet_Id, Client.DBContext);
await ctx.ReplyAsync($"Your {task.TaskType} daily task is done! You get {task.Reward} coins.");
}
}
}
double payout = (double)rnd.Next(30, 50);
DBUser.Coins += payout;
DBUser.LastHourly = DateTime.UtcNow;
await Client.DBContext.AddStat("Coins", payout, ctx.Message.Planet_Id, Client.DBContext);
await Client.DBContext.SaveChangesAsync();
await ctx.ReplyAsync($"Your got {payout} coins!");
}
else
{
await ctx.ReplyAsync($"You must wait {minutesleft} minutes before you can get another payout");
return;
}
}
public TaskForm(Form mdiParent, DailyTask dt)
{
InitializeComponent();
this.ControlBox = false;
this.MdiParent = mdiParent;
this.MouseDown += TaskForm_MouseDown;
this.MouseMove += TaskForm_MouseMove;
this.MouseUp += TaskForm_MouseUp;
this.DailyTask = dt;
try
{
this.lb_Title.DataBindings.Add("Text", DailyTask, "Title", true, DataSourceUpdateMode.OnPropertyChanged);
this.lb_Date.DataBindings.Add("Text", DailyTask, "Date", true, DataSourceUpdateMode.OnPropertyChanged);
this.metroLabel1.DataBindings.Add("Text", DailyTask.TaskItems, "Content", true, DataSourceUpdateMode.OnPropertyChanged);
}
catch (Exception ex)
{
}
}
public ActionResult Update(int id, DailyTask taskReq)
{
try
{
if (ModelState.IsValid)
{
DailyTask tsk = _repository.GetTaskById(taskReq.DailyTaskId);
tsk.TitluTask = taskReq.TitluTask;
tsk.Prioritate = taskReq.Prioritate;
tsk.Deadline = taskReq.Deadline;
tsk.Detalii = taskReq.Detalii;
_repository.UpdateDailyTask(tsk);
_repository.SaveChanges();
return(RedirectToAction("Index"));
}
return(View("Edit", taskReq));
} catch (Exception e)
{
return(View("Edit", taskReq));
}
}
public ActionResult Update(int id, DailyTask taskReq)
{
try
{
if (ModelState.IsValid)
{
DailyTask tsk = _ctx.DailyTasks.FirstOrDefault(predicate => predicate.DailyTaskId == id);
tsk.TitluTask = taskReq.TitluTask;
tsk.Prioritate = taskReq.Prioritate;
tsk.Deadline = taskReq.Deadline;
tsk.Detalii = taskReq.Detalii;
_ctx.SaveChanges();
return(RedirectToAction("Index"));
}
return(View("Edit", taskReq));
}
catch (Exception e)
{
return(View("Edit", taskReq));
}
}
// GET: DailyTasks/Delete/5
public async Task <ActionResult> Delete(int id)
{
DailyTask dailyTask = null;
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(BaseUrl);
var result = await client.GetAsync($"api/DailyTasks/{id}");
if (result.IsSuccessStatusCode)
{
dailyTask = await result.Content.ReadAsAsync <DailyTask>();
}
else
{
ModelState.AddModelError(string.Empty, "Server error try after some time.");
}
}
return(View(dailyTask));
}
public ActionResult CreateTask(DailyTask tsk)
{
try
{
if (ModelState.IsValid)
{
var userId = User.Identity.GetUserId();
if (userId != null)
{
tsk.UserId = userId;
}
_ctx.DailyTasks.Add(tsk);
_ctx.SaveChanges();
return(RedirectToAction("Index"));
}
return(View("NewTask", tsk));
}
catch (Exception e)
{
return(View("NewTask", tsk));
}
}
public async Task OnMessage(CommandContext ctx)
{
// check if the member has a daily task
DailyTask task = await Client.DBContext.DailyTasks.FirstOrDefaultAsync(x => x.MemberId == ctx.Member.Id && x.TaskType == "Messages");
if (task != null)
{
if (task.Done < task.Goal)
{
task.Done += 1;
if (task.Done == task.Goal)
{
User DBUser = await Client.DBContext.Users.FirstOrDefaultAsync(x => x.PlanetId == ctx.Planet.Id && x.UserId == ctx.Message.Author_Id);
DBUser.Coins += task.Reward;
await Client.DBContext.AddStat("Coins", task.Reward, ctx.Message.Planet_Id, Client.DBContext);
await ctx.ReplyAsync($"Your {task.TaskType} daily task is done! You get {task.Reward} coins.");
}
await Client.DBContext.SaveChangesAsync();
}
}
}
public async Task <IActionResult> PutDailyTask(int id, DailyTask dailyTask)
{
if (id != dailyTask.Id)
{
return(BadRequest());
}
var authorizationResult = await _authorizationService.AuthorizeAsync(User, dailyTask, Operations.Update);
if (authorizationResult.Succeeded)
{
_context.Entry(dailyTask).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DailyTaskExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
else
{
return(new ForbidResult());
}
}
public void SetData(DailyTask task, DailyTaskType type, bool isGoldBuy, Action <DailyTaskItem> clickCallBack = null)
{
this.mTask = task;
this.mType = type;
this.mEventHandler = clickCallBack;
this.mDailyData = DataReader <MeiRiMuBiao> .Get(this.mTask.taskId);
if (this.mDailyData != null)
{
if (this.mFxId > 0)
{
FXSpineManager.Instance.DeleteSpine(this.mFxId, true);
this.mFxId = 0;
}
if (this.mDailyData.Retrieve == 1)
{
this.mFindData = DataReader <MZhaoHui> .Get(this.mTask.taskId);
}
ResourceManager.SetSprite(this.mIcon, GameDataUtils.GetIcon(this.mDailyData.iconId));
this.mTxName.set_text(GameDataUtils.GetChineseContent(this.mDailyData.introduction1, false));
switch (this.mType)
{
case DailyTaskType.DAILY:
this.SetDailyData(this.mDailyData);
break;
case DailyTaskType.FIND:
this.SetFindData(this.mFindData, isGoldBuy);
break;
case DailyTaskType.LIMIT:
this.SetTimeData(this.mDailyData);
break;
}
}
}
// GET: DailyTasks/Details/5
public async Task <ActionResult> Details(int id)
{
DailyTask dailyTask = null;
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(BaseUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var result = await client.GetAsync($"api/DailyTasks/{id}");
if (result.IsSuccessStatusCode)
{
dailyTask = await result.Content.ReadAsAsync <DailyTask>();
}
else
{
ModelState.AddModelError(string.Empty, "Server error try after some time.");
}
}
return(View(dailyTask));
}
public ActionResult NewTask()
{
DailyTask tsk = new DailyTask();
return(View(tsk));
}
public async Task Dice(CommandContext ctx, double bet)
{
User DBUser = await Client.DBContext.Users.FirstOrDefaultAsync(x => x.UserId == ctx.Message.Author_Id && x.PlanetId == ctx.Message.Planet_Id);
if (DBUser.Coins < bet)
{
await ctx.ReplyAsync("Bet must not be above your coins!");
return;
}
// check if the member has a daily task
DailyTask task = await Client.DBContext.DailyTasks.FirstOrDefaultAsync(x => x.MemberId == ctx.Member.Id && x.TaskType == "Dice Games Played");
if (task != null)
{
if (task.Done < task.Goal)
{
task.Done += 1;
if (task.Done == task.Goal)
{
DBUser.Coins += task.Reward;
await Client.DBContext.AddStat("Coins", task.Reward, ctx.Message.Planet_Id, Client.DBContext);
await ctx.ReplyAsync($"Your {task.TaskType} daily task is done! You get {task.Reward} coins.");
}
await Client.DBContext.SaveChangesAsync();
}
}
int usernum1 = rnd.Next(1, 6);
int usernum2 = rnd.Next(1, 6);
int opnum1 = rnd.Next(1, 6);
int opnum2 = rnd.Next(1, 6);
List <string> data = new List <string>();
data.Add($"You throw the dice");
data.Add($"You get **{usernum1}** and **{usernum2}**");
data.Add($"Your opponent throws their dice, and gets **{opnum1}** and **{opnum2}**");
// check for a tie
if (usernum1 + usernum2 == opnum1 + opnum2)
{
data.Add($"It's a tie");
}
else
{
// user won
if (usernum1 + usernum2 > opnum1 + opnum2)
{
data.Add($"You won {bet} coins!");
DBUser.Coins += bet;
await Client.DBContext.AddStat("Coins", bet, ctx.Message.Planet_Id, Client.DBContext);
}
else
{
data.Add($"You lost {bet} coins.");
DBUser.Coins -= bet;
await Client.DBContext.AddStat("Coins", 0 - bet, ctx.Message.Planet_Id, Client.DBContext);
}
}
await Client.DBContext.SaveChangesAsync();
ctx.ReplyWithMessagesAsync(1750, data);
}
public void DailyTaskCanBeCreated()
{
DailyTask task = new DailyTask();
}
public async Task <DailyTask> updateOne([FromBody] DailyTask task)
{
return(await taskService.updateTask(task));
}
public async Task <DailyTask> createTask([FromBody] DailyTask task)
{
return(await taskService.addTask(task));
}
public async Task GenerateNewDailyTasks(PopeAIDB Context, ulong Memberid)
{
string[] types = new string[] { "Messages", "Hourly Claims", "Gamble Games Played", "Dice Games Played" };
List <DailyTask> toadd = new List <DailyTask>();
for (int i = 0; i < 3; i++)
{
DailyTask task = new DailyTask();
string tasktype = types[rnd.Next(0, types.Count())];
while (toadd.Any(x => x.TaskType == tasktype))
{
tasktype = types[rnd.Next(0, types.Count())];
}
task.TaskType = tasktype;
int id = rnd.Next(0, int.MaxValue);
while (await Context.DailyTasks.AnyAsync(x => x.Id == (ulong)id))
{
id = rnd.Next(0, int.MaxValue);
}
task.Id = (ulong)id;
task.LastDayUpdated = DateTime.UtcNow;
task.MemberId = Memberid;
switch (tasktype)
{
case "Messages":
double[] goals = new double[] { 10, 15, 20, 25, 30, 35, 40, 45, 50 };
task.Goal = goals[rnd.Next(0, goals.Count())];
task.Done = 0;
double[] rewards = new double[] { 50, 75, 100, 125, 150, 175, 200, 225, 250, 275, 300 };
task.Reward = rewards[rnd.Next(0, rewards.Count())];
break;
case "Hourly Claims":
goals = new double[] { 3, 4, 5 };
task.Goal = goals[rnd.Next(0, goals.Count())];
task.Done = 0;
rewards = new double[] { 50, 75, 100, 125, 150, 175, 200, 225, 250 };
task.Reward = rewards[rnd.Next(0, rewards.Count())];
break;
case "Gamble Games Played":
goals = new double[] { 5, 6, 7, 8, 9, 10 };
task.Goal = goals[rnd.Next(0, goals.Count())];
task.Done = 0;
rewards = new double[] { 50, 75, 100, 125, 150, 175, 200 };
task.Reward = rewards[rnd.Next(0, rewards.Count())];
break;
case "Dice Games Played":
goals = new double[] { 5, 6, 7, 8, 9, 10 };
task.Goal = goals[rnd.Next(0, goals.Count())];
task.Done = 0;
rewards = new double[] { 50, 75, 100, 125, 150, 175, 200, 225, 250, 275, 300 };
task.Reward = rewards[rnd.Next(0, rewards.Count())];
break;
}
toadd.Add(task);
await Context.AddAsync(task);
}
}
