public async Task InsertUser(User user, string extUserId)
{
if (await EnsureLogin() && !string.IsNullOrWhiteSpace(extUserId))
{
var userInUser =
await MobileService.GetTable <User>().Where(u => u.Email == user.Email).ToCollectionAsync();
if (userInUser.SingleOrDefault() == null)
{
await MobileService.GetTable <User>().InsertAsync(user);
}
else
{
user = userInUser.Single();
}
//await table.InsertAsync(user);
ExternalUser externalUser = new ExternalUser()
{
Id = Guid.NewGuid().ToString(),
UserId = user.Id,
ExternalUserId = extUserId,
UserDomainId =
(await
MobileService.GetTable <UserDomain>()
.Where(u => u.DomainKey == (int)UserDomainEnum.Microsoft)
.ToCollectionAsync()).Single().Id
};
await AddExternalUser(externalUser);
await AddUserGroup(user);
}
}
public async Task <string> UserExist(string userId)
{
if (await EnsureLogin())
{
//var usrDB = MobileService.GetTable<ExternalUser>().Where(u => u.ExternalUserId == userId).ToListAsync();
// var usrDB = MobileService.GetTable<ExternalUser>().Where(u => u.ExternalUserId == userId).Select(u =>u.Id);
//string usrDB = MobileService.GetTable<ExternalUser>().Where(u => u.ExternalUserId == userId).ToString();
try
{
var table = await MobileService.GetTable <ExternalUser>()
.Where(u => u.ExternalUserId == userId)
.ToCollectionAsync();
var usrDB = table.SingleOrDefault();
if (usrDB == null)
{
return(null);
}
else
{
return(usrDB.UserId);
}
}
catch (Exception ex)
{
}
}
return(null);
}
public async Task <User> GetUser(string externalUserId, UserDomainEnum currentUserDomain)
{
if (await EnsureLogin())
{
try
{
var domainsTable = MobileService.GetTable <UserDomain>();
var domains = await domainsTable.ToCollectionAsync();
var currentDomain = domains.Single(d => d.DomainKey == (int)currentUserDomain);
var extUsers = await MobileService.GetTable <ExternalUser>().ToListAsync();
var currentExtUser =
extUsers.Single(u => u.ExternalUserId == externalUserId && u.UserDomainId == currentDomain.Id);
var users = await MobileService.GetTable <User>().ToListAsync();
var user = users.Single(u => u.Id == currentExtUser.UserId);
return(user);
}
catch (Exception ex)
{
}
return(null);
}
return(null);
}
public async Task AddUserGroup(User user)
{
var userGroups = await MobileService.GetTable <UserGroup>().Where(t => t.UserId == user.Id).ToCollectionAsync();
var userGroupExist = userGroups.Where(i => i.IsUserDefaultGroup);
var userHasGroup = userGroupExist.FirstOrDefault();
if (userHasGroup == null)
{
Group group = new Group()
{
Id = Guid.NewGuid().ToString(),
GroupName = "Default group for user: " + user.Id
};
await MobileService.GetTable <Group>().InsertAsync(group);
var roles =
await MobileService.GetTable <RoleType>().Where(r => r.RoleKey == (int)RoleTypeEnum.Admin).ToCollectionAsync();
var userRoleId = roles.Single().Id;
UserGroup userGroup = new UserGroup()
{
Id = Guid.NewGuid().ToString(),
UserId = user.Id,
GroupId = group.Id,
RoleTypeId = userRoleId,
IsUserDefaultGroup = true
};
await MobileService.GetTable <UserGroup>().InsertAsync(userGroup);
}
}
private async Task AddUserGroup(User user)
{
var userGroups = await MobileService.GetTable <UserGroup>().ToListAsync();
var userGroup = userGroups.Where(ug => ug.UserId == user.Id);
if (userGroup.FirstOrDefault() == null)
{
Group group = new Group()
{
Id = Guid.NewGuid().ToString(),
GroupName = "Default group for user: " + user.Id
};
await MobileService.GetTable <Group>().InsertAsync(@group);
var availableRoles = await MobileService.GetTable <RoleType>().ToListAsync();
var adminRole = availableRoles.Where(r => r.RoleKey == (int)UserRoleEnum.Admin);
UserGroup ug = new UserGroup()
{
Id = Guid.NewGuid().ToString(),
GroupId = @group.Id,
UserId = user.Id,
RoleTypeId = adminRole.Single().Id,
IsUserDefaultGroup = true
};
await MobileService.GetTable <UserGroup>().InsertAsync(ug);
}
}
public static async Task <Status> AddJorunal(Accounts account)
{
try
{
if (account.id == null)
{
await MobileService.GetTable <Accounts>().InsertAsync(account);
}
else
{
await MobileService.GetTable <Accounts>().UpdateAsync(account);
}
return(new Models.Status()
{
result = true, message = "Successfully Added"
});
}
catch (Exception e)
{
return(new Models.Status()
{
result = false, message = e.ToString()
});
}
}
public async Task InsertTodoItem(ToDoItem toDoItem)
{
if (await EnsureLogin())
{
await MobileService.GetTable <ToDoItem>().InsertAsync(toDoItem);
}
}
public async Task <IEnumerable <Place> > GetPlacesAsync(int skip = 0, int take = 100)
{
var places = MobileService.GetTable <Place>();
var result = await places.Skip(skip).Take(take).ToListAsync();
return(result);
}
public async Task <ObservableCollection <Group> > GetGroupForUser(string externalUserId)
{
if (await EnsureLogin())
{
try
{
var extUsers = await MobileService.GetTable <ExternalUser>().ToListAsync();
var currentExtUser = extUsers.Single(u => u.ExternalUserId == externalUserId);
var allUserGroups = await MobileService.GetTable <UserGroup>().ToListAsync();
var userGroups = allUserGroups.Where(ug => ug.UserId == currentExtUser.UserId);
List <string> groupIds = userGroups.Select(ug => ug.GroupId).ToList();
var allGroups = await MobileService.GetTable <Group>().ToListAsync();
var availableGroups = allGroups.Where(g => groupIds.Contains(g.Id));
return(availableGroups.ToObservableCollection());
}
catch (Exception ex)
{
}
}
return(null);
}
// GET: ShopItems
public async Task <ActionResult> Index()
{
//return View(await db.ShopItems.ToListAsync());
var itemlist = await MobileService.GetTable <ShopItems>().ToListAsync();
return(View(itemlist));
}
public async Task <System.Collections.ObjectModel.ObservableCollection <TaskSubitem> > GetUserTaskSubitemsAlreadyStarted(string userId)
{
if (await EnsureLogin())
{
var taskService = new TaskItemService(base.AccessToken);
var taskItems = await taskService.GetTaskItems(userId);
var result = new List <TaskSubitem>();
foreach (var taskItem in taskItems)
{
var taskSubitems =
await
MobileService.GetTable <TaskSubitem>()
.Where(t => t.TaskItemId == taskItem.Id && t.TaskStatusId != ((int)TaskStatusEnum.Completed).ToString() && t.TaskStatusId != ((int)TaskStatusEnum.Rejected).ToString())
.ToCollectionAsync();
Func <TaskSubitem, bool> func = t => t.ExecutorId == userId && t.StartDateTime.HasValue && t.StartDateTime.Value.Date <= DateTime.Today &&
t.StartDateTime.Value.Date > DateTime.Today.AddDays(-2);
if (taskSubitems.Any(func))
{
result.AddRange(taskSubitems.Where(func));
}
}
return(result.ToObservableCollection());
}
return(null);
}
public async Task <ObservableCollection <TaskSubitem> > GetCompletedTaskSubitems(string userId, DateTime fromDate, DateTime toDate)
{
if (await EnsureLogin())
{
var taskService = new TaskItemService(base.AccessToken);
var taskItems = await taskService.GetTaskItems(userId);
var result = new List <TaskSubitem>();
foreach (var taskItem in taskItems)
{
var taskSubitems =
await
MobileService.GetTable <TaskSubitem>()
.Where(t => t.TaskItemId == taskItem.Id && t.TaskStatusId == ((int)TaskStatusEnum.Completed).ToString())
.ToCollectionAsync();
Func <TaskSubitem, bool> func = t => t.ExecutorId == userId && t.StartDateTime.HasValue && t.StartDateTime.Value.Date >= fromDate.Date &&
t.EndDateTime.HasValue && t.EndDateTime.Value.Date < toDate.Date;
if (taskSubitems.Any(func))
{
result.AddRange(taskSubitems.Where(func));
}
}
return(result.ToObservableCollection());
}
return(null);
}
private async Task AddExtUser(User user, UserDomainsEnum userDomainEnum, string externalUserId)
{
var userDomainsTable = MobileService.GetTable <UserDomain>();
var userDomains = await userDomainsTable.ToCollectionAsync();
var domain = userDomains.SingleOrDefault(d => d.DomainKey == (int)userDomainEnum);
if (domain != null)
{
var externalUserstable = MobileService.GetTable <ExternalUser>();
var externalUsers = await externalUserstable.ToCollectionAsync();
var extUsers = externalUsers.Where(eu => eu.UserId == user.Id && eu.UserDomainId == domain.Id);
if (extUsers.SingleOrDefault() == null)
{
ExternalUser extUser = new ExternalUser()
{
Id = Guid.NewGuid().ToString(),
UserId = user.Id,
ExternalUserId = externalUserId,
UserDomainId = domain.Id
};
await externalUserstable.InsertAsync(extUser);
}
}
}
public async static Task <Status> AddLedger(Ledgers ledger)
{
try
{
if (ledger.id == null)
{
await MobileService.GetTable <Ledgers>().InsertAsync(ledger);
}
else
{
await MobileService.GetTable <Ledgers>().UpdateAsync(ledger);
}
return(new Models.Status()
{
result = true, message = "Successfully Added"
});
}
catch (Exception e)
{
return(new Models.Status()
{
result = false, message = e.ToString()
});
}
}
private async Task getUserAddresses()
{
try
{
RefreshView.IsRefreshing = true;
var getAddresseses = await MobileService.GetTable <TBL_Addresses>().Where(usersId => usersId.user_id == user_id).ToListAsync();
ListAddress.ItemsSource = getAddresseses;
RefreshView.IsRefreshing = false;
if (getAddresseses.Count == 0)
{
imgnofound.IsVisible = true;
ListAddress.IsVisible = false;
}
else
{
imgnofound.IsVisible = false;
ListAddress.IsVisible = true;
}
}
catch
{
RefreshView.IsRefreshing = false;
await Navigation.PushAsync(new NoInternetPage(), false);
}
}
public async Task <System.Collections.ObjectModel.ObservableCollection <TaskSubitem> > GetUserTaskSubitemsNearDeadlines(string userId)
{
return(await ExecuteAuthenticated(async() =>
{
var taskService = SimpleIoc.Default.GetInstance <ITaskItemDataService>();
var taskItems = await taskService.GetTaskItems(userId);
var result = new List <TaskSubitem>();
foreach (var taskItem in taskItems)
{
var taskSubitems =
await
MobileService.GetTable <TaskSubitem>()
.Where(t => t.TaskItemId == taskItem.Id && t.TaskStatusId != ((int)TaskStatusEnum.Completed).ToString() && t.TaskStatusId != ((int)TaskStatusEnum.Rejected).ToString())
.ToCollectionAsync();
Func <TaskSubitem, bool> func = t => t.ExecutorId == userId && t.EndDateTime.HasValue && t.EndDateTime.Value.Date >= DateTime.Today &&
t.EndDateTime.Value.Date < DateTime.Today.AddDays(3);
if (taskSubitems.Any(func))
{
result.AddRange(taskSubitems.Where(func));
}
}
return result.ToObservableCollection();
}));
}
public async Task UpdateGroup(Group group)
{
if (await EnsureLogin())
{
await MobileService.GetTable <Group>().UpdateAsync(group);
}
}
public async static Task <Status> Signup(Users user)
{
try
{
var users = await MobileService.GetTable <Users>().Where(x => x.email == user.email).ToListAsync();
if (users.FirstOrDefault() == null)
{
await MobileService.GetTable <Users>().InsertAsync(user);
return(new Models.Status()
{
result = true, message = "Successfully Registered"
});
}
else
{
return(new Models.Status()
{
result = false, message = "Already Registererd"
});
}
}
catch (Exception e)
{
return(new Models.Status()
{
result = false, message = e.ToString()
});
}
}
private async void CheckForAutoLogin()
{
if (Settings.LastUsedEmail != string.Empty)
{
var users = (await MobileService.GetTable <TBL_Users>().Where(mail => mail.emailadd == Settings.LastUsedEmail).ToListAsync()).FirstOrDefault();
if (users != null)
{
user_id = users.Id;
fullname = users.full_name;
mobilenum = users.mobile_num;
emailadd = users.emailadd;
password = users.password;
datereg = users.datereg;
propic = users.propic;
picstr = users.picstr;
//user_id = null;
CurrentOrderId = null;
refresh = false;
//indicatorloader.IsVisible = false;
//Settings.LastUsedEmail = chkremember.IsChecked ? emailentry.Text : "";
//await DisplayAlert("Success", "Email or password is incorrect!", "OK");
Device.BeginInvokeOnMainThread(() => { Xamarin.Forms.Application.Current.MainPage = new AppShell(); });
await Navigation.PushAsync(new MenuPage(), true);
//var page = MenuPage as NavigationPage;
}
}
else
{
Device.BeginInvokeOnMainThread(() => { Xamarin.Forms.Application.Current.MainPage = new LoginPage(); });
await Navigation.PushAsync(new LoginPage(), true);
}
}
public async Task <ObservableCollection <Group> > GetGroupsAvailableForUserWhereUserIsAdmin(string externalUserId)
{
if (await EnsureLogin())
{
var extUsers = await MobileService.GetTable <ExternalUser>().ToListAsync();
var currentExtUser = extUsers.Single(u => u.ExternalUserId == externalUserId);
var allUserGroups = await MobileService.GetTable <UserGroup>().ToListAsync();
var userGroups = allUserGroups.Where(ug => ug.UserId == currentExtUser.UserId);
List <string> groupIds = userGroups.Select(ug => ug.GroupId).ToList();
var allGroups = await MobileService.GetTable <Group>().ToListAsync();
var availableGroups = allGroups.Where(g => groupIds.Contains(g.Id));
var roleTypeService = new RoleTypeService(base.AccessToken);
var groupsWhereUserIsAdmin = new ObservableCollection <Group>();
foreach (var group in availableGroups)
{
if (await roleTypeService.CanUserAddOrDeleteItem(currentExtUser.UserId, group.Id))
{
groupsWhereUserIsAdmin.Add(group);
}
}
return(groupsWhereUserIsAdmin.ToObservableCollection());
}
return(null);
}
public async Task <bool> InsertTaskSubitem(Model.DTO.TaskSubitem taskSubitem)
{
return(await ExecuteAuthenticated(async() =>
{
await MobileService.GetTable <TaskSubitem>().InsertAsync(taskSubitem);
return true;
}));
}
public async Task <bool> Update(UserGroup userGroup)
{
return(await ExecuteAuthenticated(async() =>
{
await MobileService.GetTable <UserGroup>().UpdateAsync(userGroup);
return true;
}));
}
public async Task <bool> DeleteUserGroup(Model.DTO.UserGroup userGroup)
{
return(await ExecuteAuthenticated(async() =>
{
await MobileService.GetTable <UserGroup>().DeleteAsync(userGroup);
return true;
}));
}
public async Task <User> GetUserById(string id)
{
return(await ExecuteAuthenticated(async() =>
{
var users = await MobileService.GetTable <User>().Where(u => u.Id == id).ToCollectionAsync();
return users.SingleOrDefault();
}));
}
public async Task <bool> Delete(Model.DTO.TaskSubitemWork taskSubitemWork)
{
return(await ExecuteAuthenticated(async() =>
{
await MobileService.GetTable <TaskSubitemWork>().DeleteAsync(taskSubitemWork);
return true;
}));
}
public async Task <User> GetUsersByEmail(string email)
{
return(await ExecuteAuthenticated(async() =>
{
var users = await MobileService.GetTable <User>().ToCollectionAsync();
return users.SingleOrDefault(u => u.Email == email);
}));
}
public async Task <TaskItem> GetTaskItemById(string taskId)
{
return(await ExecuteAuthenticated(async() =>
{
var taskItem = await MobileService.GetTable <TaskItem>().Where(t => t.Id == taskId).ToCollectionAsync();
return taskItem.SingleOrDefault();
}));
}
public async Task <ObservableCollection <DTO.TaskStatus> > GetAvailableTaskStatuses()
{
if (await EnsureLogin())
{
return(await MobileService.GetTable <DTO.TaskStatus>().ToCollectionAsync());
}
return(null);
}
public async Task <IEnumerable <Entities.Feedback> > GetFeedbacksAsync(string placeId, int skip = 0, int take = 100)
{
var feedbacks = MobileService.GetTable <Entities.Feedback>();
var result = await feedbacks.Where(feedback => feedback.PlaceId == placeId)
.OrderByDescending(feedback => feedback.CreationDate)
.Skip(skip).Take(100).ToListAsync();
return(result);
}
public async Task <bool> UpdateTodoList(TodoList list)
{
return(await ExecuteAuthenticated(async() =>
{
var table = MobileService.GetTable <TodoList>();
await table.UpdateAsync(list);
return true;
}));
}
