public ActionResult Index()
{
var container = AppStatisticsService.GetAdminDashboardStatistics();
var viewModel = new AdminDashboardViewModel(container);
return(View(viewModel));
}
public ActionResult AdminDashboard()
{
var todaysStatistics = _unitOfWork.DailyStatistics.GetTodays();
var lastMonthStatistics = _unitOfWork.DailyStatistics
.GetRecordsFromLastDays(30) as IList <DailyStatistics>;
var dashboardViewModel = new AdminDashboardViewModel
{
TotalUsers = _unitOfWork.DailyStatistics.GetTotalUsers(),
NewUsersToday = todaysStatistics.NewUsers,
DeletedUsersToday = todaysStatistics.DeletedUsers,
TotalPublicPolls = _unitOfWork.DailyStatistics.GetTotalPublicPolls(),
NewPublicPollsToday = todaysStatistics.NewPublicPolls,
DeletedPublicPollsToday = todaysStatistics.DeletedPublicPolls,
TotalPrivatePolls = _unitOfWork.DailyStatistics.GetTotalPrivatePolls(),
NewPrivatePollsToday = todaysStatistics.NewPrivatePolls,
DeletedPrivatePollsToday = todaysStatistics.DeletedPrivatePolls,
TotalPageViews = _unitOfWork.DailyStatistics.GetTotalPageViews(),
PageViewsToday = todaysStatistics.PageViews,
TotalUniqueVisitors = _unitOfWork.DailyStatistics.GetTotalUniqueVisitors(),
UniqueVisitorsToday = todaysStatistics.UniqueVisitors,
LastMonthUniqueVisitors = new Tuple <IEnumerable <int>, IEnumerable <DateTime> >(
lastMonthStatistics.Select(ds => ds.UniqueVisitors).ToList(),
lastMonthStatistics.Select(ds => ds.Date).ToList())
};
return(View(dashboardViewModel));
}
public ActionResult AdminDashboard()
{
var numberOfCustomerAccounts = 0;
var numberOfGlAccounts = 0;
var numberOfLoans = 0;
decimal profit = 0;
if (_customerAccContext.GetAllCustomersAccounts() != null)
{
numberOfCustomerAccounts = _customerAccContext.GetAllCustomersAccounts().Count();
}
if (_glAccountContext.GetAll() != null)
{
numberOfGlAccounts = _glAccountContext.GetAll().Count();
}
if (_loanContext.GetAllLoans() != null)
{
numberOfLoans = _loanContext.GetAllLoans().Count();
}
if (_transactionReportContext.GetProfitOrLoss() != 0)
{
profit = _transactionReportContext.GetProfitOrLoss();
}
var viewModel = new AdminDashboardViewModel
{
NumberOfCustomerAccounts = numberOfCustomerAccounts,
Profit = profit,
NumberOfGlAccounts = numberOfGlAccounts,
NumberOfLoans = numberOfLoans,
};
return(View("AdminDashboard", viewModel));
}
public AdminDashboardViewModel GetAdminDashboard(int userId)
{
var findUser = (from user in _context.Users
where user.UserId == userId
select user.UserId).FirstOrDefault();
int techId = Convert.ToInt32(findUser);
int RoleCount = (from role in _context.Role
select role.RoleId).Count();
int DepartmentCount = (from department in _context.Department
select department.DepartmentId).Count();
int TotalCoordinator = (from coordinator in _context.Coordinator
select coordinator.CoordinatorId).Count();
int TotalProgram = (from program in _context.Program
select program.ProgramID).Count();
var result = new AdminDashboardViewModel
{
TotalRole = RoleCount,
TotalCoordinator = TotalCoordinator,
TotalDepartment = DepartmentCount,
TotalProgram = TotalProgram
};
return(result);
}
public async Task <IActionResult> Index()
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.AccessAdminDashboard))
{
return(Forbid());
}
var widgets = await _adminDashboardService.GetWidgetsAsync(x => x.Published);
var wrappers = new List <DashboardWrapper>();
foreach (var item in widgets)
{
wrappers.Add(new DashboardWrapper
{
Dashboard = item,
Content = await _contentItemDisplayManager.BuildDisplayAsync(item, _updateModelAccessor.ModelUpdater, "DetailAdmin")
});
}
var model = new AdminDashboardViewModel
{
Dashboards = wrappers.ToArray()
};
return(View(model));
}
public async Task <IActionResult> Index()
{
try
{
var numberOfActiveCinemas = _context.TblCinema.Where(r => r.IsDeleted == false).Count();
var numberOfPassiveCinemas = _context.TblCinema.Where(r => r.IsDeleted == true).Count();
var TicketsSold = _context.TblTicket.Count();
var numberOfActiveMovies = _context.TblMovie.Where(r => r.IsDeleted == false).Count();
var numberOfCinemas = _context.TblCinema.Count();
var numberOfCustomers = await _userManager.GetUsersInRoleAsync("SimpleUser");
AdminDashboardViewModel adminDashboard = new AdminDashboardViewModel();
adminDashboard.NumberOfActiveCinemas = numberOfActiveCinemas;
adminDashboard.NumberOfPassiveCinemas = numberOfPassiveCinemas;
adminDashboard.NumberTicketsSold = TicketsSold;
adminDashboard.ActiveMovies = numberOfActiveMovies;
adminDashboard.CinemasRegistered = numberOfCinemas;
adminDashboard.CustomersRegistered = numberOfCustomers.Count;
return(View(adminDashboard));
}
catch (Exception ex)
{
return(View("Index", null).WithSuccess("Error!", ex.Message));
}
}
public ActionResult Index()
{
var comments = _commentRepository.GetAllComments();
var posts = _postRepository.GetPostsByUserID(GetUserId()).Select(p => p.PostID);
var filteredComments = comments.Where(c => posts.Contains(c.PostID)).ToList();
var model = new AdminDashboardViewModel
{
PostCount = _postRepository.GetPostsByUserID(GetUserId(), 1).Count,
PagesCount = _postRepository.GetPostsByUserID(GetUserId(), 2).Count, // at this point non-admin users cannot add pages
CategoriesCount = _categoryRepository.GetCategories().Count,
TagsCount = _tagRepository.GetAllTags().Count,
AllCommentsCount = filteredComments.Count(),
ApprovedCount = filteredComments.Count(c => c.CommentStatus == 0),
PendingCount = filteredComments.Count(c => c.CommentStatus == 1),
SpamCount = filteredComments.Count(c => c.CommentStatus == 2),
CanView = GetUserId() == 1,
BlogName = SettingsRepository.BlogName
};
return(View(model));
}
// GET: Admin
public ActionResult Dashboard()
{
if (Session["ID"] != null)
{
int id = Convert.ToInt32(Session["ID"]);
int RoleMember = Convert.ToInt32(Enums.UserRoleId.Member);
User user = db.Users.Where(x => x.ID == id).FirstOrDefault();
if (user.RoleID != RoleMember)
{
int statusInReview = Convert.ToInt32(Enums.ReferenceNoteStatus.InReview);
int statusSubmittedForReview = Convert.ToInt32(Enums.ReferenceNoteStatus.SubmittedForReview);
int member = Convert.ToInt32(Enums.UserRoleId.Member);
AdminDashboardViewModel Model = new AdminDashboardViewModel();
Model.NotesUnderReviewCount = db.SellNotes.Where(x => x.Status == (statusInReview) || x.Status == (statusSubmittedForReview)).Count();
var date = DateTime.Now.AddDays(-7).Date;
Model.NewDownloadCount = db.Downloads.Where(x => x.CreatedDate > date).Count();
Model.NewRegistrationCount = db.Users.Where(x => x.CreatedDate > date && x.RoleID == member).Count();
return(View(Model));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
return(RedirectToAction("Login", "Account"));
}
}
public ActionResult Dashboard()
{
var model = new AdminDashboardViewModel();
model.Populate(db);
return(View(model));
}
//
// GET: /Admin/Home/
public virtual ActionResult Index()
{
var model = new AdminDashboardViewModel
{
TotalEvents = _es.Count(),
TotalUsers = _us.GetActiveUserCount(),
EventsToday = _db.Events.Count(e => e.CreatedDateTime >= DateTime.UtcNow.AddDays(-1)),
EventsYesterday =
_db.Events.Count(
e =>
e.CreatedDateTime >= DateTime.UtcNow.AddDays(-2) &&
e.CreatedDateTime <= DateTime.UtcNow.AddDays(-1)),
AvgNumberOfEventsPerDay = 0,
EventsThisWeek = _db.Events.Count(e => e.CreatedDateTime >= DateTime.UtcNow.AddDays(-7)),
EventsLastWeek =
_db.Events.Count(
e =>
e.CreatedDateTime >= DateTime.UtcNow.AddDays(-14) &&
e.CreatedDateTime <= DateTime.UtcNow.AddDays(-7))
};
return View(model);
}
// GET: /Admin
public ActionResult Index(int?i)
{
var keys = HttpContext.Application.AllKeys;
if (User.IsInRole(UserRoles.CanAddJobs))
{
IEnumerable <Application> applications = _applicationsRepo.GetApplications(new Guid()).ToList();
AdminDashboardViewModel model = new AdminDashboardViewModel()
{
AdminMail = User.Identity.Name,
NoOfAcceptedApplications = applications
.Where(x => x.ApplicationStatus == JobApplicationResponse.Accepted).Count(),
NoOfApplicants = _applicationsRepo.GetAllApplicants().Count() - 1,
NoOfNotReviewedApplications = applications
.Where(x => x.ApplicationStatus == JobApplicationResponse.NotReviewed).Count(),
NoOfJobs = _jobRepo.GetActiveJobs().Count(),
NoOfApplications = applications.Count(),
NoOfRejectedApplications = applications
.Where(x => x.ApplicationStatus == JobApplicationResponse.Rejected).Count(),
};
return(View("AdminDashboard", model));
}
return(RedirectToAction("Login", "Account", new { returnUrl = "/Admin/Index" }));
}
public async Task <IActionResult> OrderDetail(int id)
{
var users = await _userManager.GetUsersInRoleAsync(ApplicationRoles.Member);
var orders = _order.GetAllClosed();
var order = orders.FirstOrDefault(o => o.ID == id);
order.Items = _basket.GetItems(order.BasketId);
List <Product> products = new List <Product>();
foreach (BasketItem item in order.Items)
{
var product = await _inventory.GetById(item.ItemId);
products.Add(product);
}
AdminDashboardViewModel advm = new AdminDashboardViewModel
{
Products = products,
Order = order,
Users = users.ToList()
};
return(View(advm));
}
public ActionResult GetFilterDashboard(int month = 0)
{
AdminDashboardViewModel Model = new AdminDashboardViewModel();
Model.getDahboardData_Results = db.NewGetDashboadrd(month).ToList();
return(PartialView("_Dashboard", Model));
}
public async Task <IActionResult> Manage()
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageAdminDashboard))
{
return(Forbid());
}
// Set Manage Dashboard Feature
Request.HttpContext.Features.Set(new DashboardFeature()
{
IsManageRequest = true
});
var dashboardCreatable = new List <SelectListItem>();
var widgetContentTypes = _contentDefinitionManager.ListTypeDefinitions()
.Where(t =>
!string.IsNullOrEmpty(t.GetSettings <ContentTypeSettings>().Stereotype) &&
t.GetSettings <ContentTypeSettings>().Stereotype.Contains("DashboardWidget"))
.OrderBy(x => x.DisplayName);
foreach (var ctd in widgetContentTypes)
{
var contentItem = await _contentManager.NewAsync(ctd.Name);
contentItem.Owner = User.FindFirstValue(ClaimTypes.NameIdentifier);
var authorized = await _authorizationService.AuthorizeAsync(User, CommonPermissions.EditContent, contentItem);
if (authorized)
{
dashboardCreatable.Add(new SelectListItem(ctd.DisplayName, ctd.Name));
}
}
var widgets = await _adminDashboardService.GetWidgetsAsync(x => x.Latest);
var wrappers = new List <DashboardWrapper>();
foreach (var item in widgets)
{
var wrapper = new DashboardWrapper
{
Dashboard = item,
Content = await _contentItemDisplayManager.BuildDisplayAsync(item, _updateModelAccessor.ModelUpdater, "DetailAdmin")
};
wrappers.Add(wrapper);
}
var model = new AdminDashboardViewModel
{
Dashboards = wrappers.ToArray(),
Creatable = dashboardCreatable
};
return(View(model));
}
public AdminDashboardViewModel UpdateVideos(string VideoID, string Title, string Description, string Genre, string RentalPrice, string Status)
{
AdminDashboardViewModel viewModel = new AdminDashboardViewModel();
VideoUpdate dac = new VideoUpdate();
UpdateVideo model = new UpdateVideo();
model = dac.UpdateVideoList(VideoID, Title, Description, Genre, RentalPrice, Status);
viewModel.VideoListUpdate = model;
return(viewModel);
}
public AdminDashboardViewModel InsertAdmin(string AdminName, string EmailAddress, string AdminPassword)
{
AdminInsert Reposi = new AdminInsert();
AdminDashboardViewModel viewModel = new AdminDashboardViewModel();
AdministrationInsert model = new AdministrationInsert();
model = Reposi.adminInesrt(AdminName, EmailAddress, AdminPassword);
viewModel.AdminInsert = model;
return(viewModel);
}
public AdminDashboardViewModel InsertVideo(string Title, string Description, string Genre, string RentalPrice)
{
AdminDashboardViewModel viewModel = new AdminDashboardViewModel();
VideoListAdd repos = new VideoListAdd();
List <AddVideo> model = new List <AddVideo>();
model = repos.AddVideoList(Title, Description, Genre, RentalPrice);
viewModel.VideoListInsert = model;
return(viewModel);
}
public AdminDashboardViewModel UpdateCustomers(string CustomerID, string CustomerName, string Address, string PhoneNumber, string Password, string EmailAddress, string Status)
{
CustomerUpdate Reposi = new CustomerUpdate();
AdminDashboardViewModel viewModel = new AdminDashboardViewModel();
UpdateCustomer model = new UpdateCustomer();
model = Reposi.UpdateCustomerList(CustomerID, CustomerName, Address, PhoneNumber, Password, EmailAddress, Status);
viewModel.CustomerListUpdate = model;
return(viewModel);
}
public ActionResult Dashboard(AdminDashboardViewModel model)
{
if (ModelState.IsValidField("ProviderName") && !ModelState.IsValidField("ProviderID"))
{
string id;
if (model.Provider != null)
{
model.Provider = model.Provider.Trim();
}
if (new TypeaheadController().FindProviderOrOrganisationByName(model.Provider, out id))
{
model.ProviderId = id;
ModelState["ProviderId"].Errors.Clear();
}
}
if (ModelState.IsValid)
{
var requestedContext = TypeaheadController.DecodeProviderId(model.ProviderId);
if (requestedContext == null)
{
ModelState.AddModelError("Provider",
AppGlobal.Language.GetText(this, "InvalidSelection",
"Invalid provider or organisation selected."));
}
else
{
var success = UserContext.SetUserContext(db, requestedContext.ContextName, requestedContext.ItemId);
if (success)
{
var userId = Permission.GetCurrentUserId();
new RecentProvisions(userId).Add(model.ProviderId, model.Provider);
if (!String.IsNullOrEmpty(model.SuccessAction) && !String.IsNullOrEmpty(model.SuccessController))
{
return(RedirectToAction(model.SuccessAction, model.SuccessController));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("Provider",
AppGlobal.Language.GetText(this, "UnableToSwitch",
"Unable to switch to the selected provider or organisation."));
}
}
if (!String.IsNullOrEmpty(model.FailureAction) && !String.IsNullOrEmpty(model.FailureController))
{
return(RedirectToAction(model.FailureAction, model.FailureController));
}
// Something happened so return the model
model.Populate(db);
return(View(model));
}
public AdminDashboardViewModel getAllcustomers()
{
CustomerGetAll dac = new CustomerGetAll();
List <AllCustomers> allcustomer = new List <AllCustomers>();
AdminDashboardViewModel viewModel = new AdminDashboardViewModel();
allcustomer = dac.GetCustomerAll();
viewModel.GetAllCustomers = allcustomer;
return(viewModel);
}
public AdminDashboardViewModel GetStatusDropdown()
{
StatusDropDown dac = new StatusDropDown();
List <Status> model = new List <Status>();
AdminDashboardViewModel viewModel = new AdminDashboardViewModel();
model = dac.GetStatus();
viewModel.DropdownStatus = model;
return(viewModel);
}
public AdminDashboardViewModel GetCustomerByID(string CustomerID)
{
CustomerGetByID Repos = new CustomerGetByID();
AdminDashboardViewModel viewModel = new AdminDashboardViewModel();
List <CustomerGetbyID> model = new List <CustomerGetbyID>();
model = Repos.GetCustomerByID(CustomerID);
viewModel.CustomerByID = model;
return(viewModel);
}
public async Task <IActionResult> UserList()
{
var users = await _userManager.GetUsersInRoleAsync(ApplicationRoles.Member);
AdminDashboardViewModel advm = new AdminDashboardViewModel
{
Users = users.ToList()
};
return(View(advm));
}
public ActionResult Index()
{
AdminDashboardViewModel model = new AdminDashboardViewModel()
{
AracSayisi = _aracRepository.GetAll().Count(),
YeniRezervasyonSayi = _islemRepository.GetMany(x => x.RezervasyonTarihi == DateTime.Today).Count(),
ToplamKiralamaBuguneKadar = _islemRepository.GetAll().Count()
};
return(View(model));
}
public AdminDashboardViewModel GetVideoByID(string VideoID)
{
VideoGetByID Repos = new VideoGetByID();
AdminDashboardViewModel viewModel = new AdminDashboardViewModel();
List <VideoGetbyID> model = new List <VideoGetbyID>();
model = Repos.GetVideobyID(VideoID);
viewModel.VideoByID = model;
return(viewModel);
}
public AdminDashboardViewModel VideoView()
{
VideoGetAll repos = new VideoGetAll();
List <AllVideos> model = new List <AllVideos>();
AdminDashboardViewModel viewModel = new AdminDashboardViewModel();
model = repos.GetAllVideo();
viewModel.VideoView = model;
return(viewModel);
}
public IActionResult AdminDashboard()
{
var activities = _context.Activity.Where(x => x.DateReferred.Year.Equals(DateTime.Now.Year));
var totalDoctors = _context.User.Where(x => x.Level.Equals("doctor")).Count();
var onlineDoctors = _context.User.Where(x => x.LoginStatus.Contains("login")).Count();
var activeFacility = _context.Facility.Count();
var referredPatients = _context.Tracking.Where(x => x.DateReferred != default || x.DateAccepted != default || x.DateArrived != default).Count();
var adminDashboard = new AdminDashboardViewModel(totalDoctors, onlineDoctors, activeFacility, referredPatients);
return(View(adminDashboard));
}
public IActionResult Index()
{
var model = new AdminDashboardViewModel
{
Users = _db.Users.OrderByDescending(u => u.Id).Take(5),
LastFiveAddedBooks = _db.Books.OrderByDescending(b => b.Id).Take(5),
LastFiveComments = _db.Comments.OrderByDescending(c => c.Id).Take(5),
LastFiveRatedBooks = _db.Rating.OrderByDescending(r => r.Id).Select(r => r.Book).Take(5)
};
return(View(model));
}
public IActionResult Index()
{
var model = new AdminDashboardViewModel()
{
LatestTransactions = mapper.Map <List <LatestTransactionsDTO>, List <LatestTransactionsViewModel> >(_salesService.GetLatestTransactions()),
FinancialInformation = mapper.Map <List <FinancialInformationDTO>, List <FinancialInformationViewModel> >(_salesService.GetDailyTakings(5)),
LowStockProducts = mapper.Map <List <ProductStockDTO>, List <ProductStockViewModel> >(_stockService.GetFiveLowestStockProducts()),
NewUsers = _userWebService.GetLatestNewUsers(5)
};
return(View(model));
}
public AdminDashboardViewModel GetAdminDashboard()
{
var model = new AdminDashboardViewModel();
model.TilesCount.NewCustomers_Count = DB.AspNetUsers.Count(x => x.Active == false);
string RoleID = DB.AspNetRoles.FirstOrDefault(x => x.Name.Equals(EnumTypes.RoleList.USER.ToString())).Id;
model.TilesCount.Customers_Count = DB.AspNetUsers.Count(x => x.Active == true && x.AspNetRoles.Any(c => c.Id == RoleID));
string SalesPerson_RoleID = DB.AspNetRoles.FirstOrDefault(x => x.Name.Trim().ToUpper().Equals(EnumTypes.RoleList.SALESPERSON.ToString().Trim().ToUpper())).Id;
model.TilesCount.SalesPerson_Count = DB.AspNetUsers.Count(x => x.Active == true && x.EmailConfirmed == true && x.AspNetRoles.Any(c => c.Id == SalesPerson_RoleID));
return(model);
}
public IActionResult Dashboard()
{
var viewModel = new AdminDashboardViewModel
{
Users = this.usersService.GetAll <AdminUsersViewModel>(),
};
if (viewModel == null)
{
return(this.View());
}
return(this.View(viewModel));
}
public ActionResult Index()
{
TempData["SelectedMenu"] = "Summary";
TempData["SelectedSubMenu"] = "";
TempData["SelectedSubMenuFolder"] = "";
User userObj = (User)Session["user"];
Account accountObj = (Account)Session["account"];
if (userObj != null)
{
//if (accountObj.isOverFlow == true)
//{
// return RedirectToAction("BillingOptions", "Admin", new { id = 1 });
//}
LimitationsViewModel limitationsObj = new LimitationsViewModel();
HelperFunctions HF = new HelperFunctions();
limitationsObj = HF.updateAccountLimitations(accountObj);
Session["limitations"] = limitationsObj;
if (userObj.isPasswordChange == false)
{
return RedirectToAction("ChangePassword", "Admin");
}
if (Session["trialData"] == null)
{
if (accountObj.HasPurchased == false)
{
if ((((DateTime)(accountObj.TrialEnds) - (DateTime)(DateTime.Now.Date)).TotalDays > (CCGlobalValues.trialPeriod - 2)) | (((DateTime)(accountObj.TrialEnds) - (DateTime)(DateTime.Now.Date)).TotalDays < 2))
{
TrialDataModel trialObj = new TrialDataModel();
trialObj.hasPurchased = accountObj.HasPurchased;
trialObj.createdDate = accountObj.CreatedDate;
trialObj.trialEndDate = accountObj.TrialEnds;
trialObj.showPurchaseOptions = true;
Session["trialData"] = trialObj;
return RedirectToAction("Index", "Admin");
}
else if (((DateTime)(accountObj.TrialEnds) - (DateTime)(DateTime.Now.Date)).TotalDays < CCGlobalValues.trialPeriod)
{
TrialDataModel trialObj = new TrialDataModel();
trialObj.hasPurchased = accountObj.HasPurchased;
trialObj.createdDate = accountObj.CreatedDate;
trialObj.trialEndDate = accountObj.TrialEnds;
trialObj.showPurchaseOptions = true;
Session["trialData"] = trialObj;
}
}
}
if (accountObj.HasPurchased == true & Session["trialData"] != null)
{
Session["trialData"] = null;
}
AdminViewModel ObjModel = new AdminViewModel();
List<AdminDashboardViewModel> objDash = new List<AdminDashboardViewModel>();
List<List<ConnectionInforViewModel>> connectionInforByConnction = new List<List<ConnectionInforViewModel>>();
if (CCFolderRepository.CCFolders != null) { }
var allFolders = CCFolderRepository.CCFolders.Where(guid => guid.AccountGUID == accountObj.AccountGUID).ToList();
ObjModel.noOfFolders = CCFolderRepository.CCFolders.Where(F => F.AccountGUID == accountObj.AccountGUID).Count();
ObjModel.noOfConnections = CCConnectionRepository.CCSubscriptions.Where(C => C.AccountGUID == accountObj.AccountGUID).Count();
ObjModel.noOfUsers = CCUserRepository.Users.Where(U => U.AccountID == userObj.AccountID).Count();
//ObjModel.noOfSubscriptionsPurchased = 0;
ObjModel.noOfTotalItems = CCItemRepository.CCContacts.Where(I => I.AccountGUID == accountObj.AccountGUID & I.isDeleted == false).Count();
// get saved quantity
var accDetails = accountRepo.Accounts.Where(aguid => aguid.AccountGUID == accountObj.AccountGUID).FirstOrDefault();
var planLeval = planRepository.Plans.Where(pid => pid.ID == accDetails.PlanID).FirstOrDefault().PlanLevel;
var featureQuality = featureRepository.Features.Where(pid => pid.PlanLevel == planLeval & pid.Type == "Max Items per Folder").FirstOrDefault();
var savedQuality = purchRepository.Purchases.Where(fid => fid.FeatureID == featureQuality.ID && fid.AccountGUID == accountObj.AccountGUID).FirstOrDefault();
if (savedQuality != null)
{
var quantitySaved = (savedQuality.Quantity) / (featureQuality.Quantity);
ObjModel.NoOfConnection = quantitySaved * 5;
ObjModel.noOfSubscriptionsPurchased = quantitySaved;
//limitationsObj.availableCconnectionCount = (int)ObjModel.NoOfConnection - (int)ObjModel.noOfConnections;
//limitationsObj.maxItemCountPerFolder = featureQuality.Quantity;
//if (featureRepository.Features.Where(pid => pid.PlanLevel == planLeval & pid.Type == "Sync Calendar").FirstOrDefault().Quantity == 0)
// limitationsObj.isCalendarSyncAvailable = false;
//else
// limitationsObj.isCalendarSyncAvailable = true;
}
else
{
ObjModel.NoOfConnection = 0;
ObjModel.noOfSubscriptionsPurchased = 0;
}
foreach (var folder in allFolders)
{
AdminDashboardViewModel dash = new AdminDashboardViewModel();
List<ConnectionInforViewModel> connectionInforByFolder = new List<ConnectionInforViewModel>();
dash.FolderName = folder.Name;
dash.FolderID = folder.FolderID;
dash.FolderType = folder.Type;
dash.NumberOfItems = CCContactRepository.CCContacts.Where(fid => fid.FolderID == folder.FolderID & fid.AccountGUID == accountObj.AccountGUID & fid.isDeleted == false).Count();
dash.NumberOfConnections = CCConnectionRepository.CCSubscriptions.Where(fid => fid.FolderID == folder.FolderID & fid.AccountGUID == accountObj.AccountGUID).Count();
if (folder.IsPaused == false)
{
dash.IsPaused = false;
}
else
{
dash.IsPaused = true;
}
objDash.Add(dash);
var connections = CCConnectionRepository.CCSubscriptions.Where(fid => fid.FolderID == folder.FolderID & fid.AccountGUID == accountObj.AccountGUID);
foreach (var conn in connections)
{
ConnectionInforViewModel connectionInfor = new ConnectionInforViewModel();
connectionInfor.FolderName = folder.Name;
connectionInfor.ConnctionFolderName = conn.FolderName;
connectionInfor.ConnectionID = conn.ConnectionID;
if (DateTime.Parse(conn.LastSyncTime) < DateTime.Parse("1902-01-01 00:00"))
{
connectionInfor.LastSyncTime = "Never";
}
else
{
DateTime timeUtc = DateTime.Parse(conn.LastSyncTime);
DateTime cstTime = new DateTime();
try
{
TimeZoneInfo cstZone = TimeZoneInfo.FindSystemTimeZoneById(accountObj.TimeZone.ToString());
cstTime = TimeZoneInfo.ConvertTimeFromUtc(timeUtc, cstZone);
Console.WriteLine("The date and time are {0} {1}.",
cstTime,
cstZone.IsDaylightSavingTime(cstTime) ?
cstZone.DaylightName : cstZone.StandardName);
}
catch (TimeZoneNotFoundException)
{
Console.WriteLine("Timezone conversion error");
}
catch (InvalidTimeZoneException)
{
Console.WriteLine("conn.LastSyncTime");
}
connectionInfor.LastSyncTime = cstTime.ToString();
//connectionInfor.LastSyncTime = conn.LastSyncTime;
}
connectionInfor.Type = conn.Type;
connectionInfor.FolderID = folder.FolderID;
if (conn.IsRunning == null) { connectionInfor.IsRunning = false; }
else if (conn.IsRunning == false) { connectionInfor.IsRunning = false; }
else if (conn.IsRunning == true) { connectionInfor.IsRunning = true; }
if (conn.IsPaused == false)
{
connectionInfor.IsPaused = false;
connectionInfor.rowClass = "notPaused ";
}
else
{
connectionInfor.IsPaused = true;
connectionInfor.rowClass = "Paused ";
}
connectionInforByFolder.Add(connectionInfor);
}
connectionInforByConnction.Add(connectionInforByFolder);
}
var assemblyVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
ViewBag.version = assemblyVersion;
Session["version"] = assemblyVersion;
ObjModel.FoldersInfor = objDash;
ObjModel.ConnectionsInfor = connectionInforByConnction;
return View(ObjModel);
}
return View();
}
