public async Task ExpenseTravelService_AddExpenseTravel_Added_NotFail_Test()
        {
            var client = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);

            var context  = new Data.MyCompanyContext();
            int expected = context.ExpenseTravels.Count() + 1;

            var expenseId = context.Expenses.Include("ExpenseTravel")
                            .Where(e => e.ExpenseTravel == null).First().ExpenseId;

            var expenseTravel = new ExpenseTravel()
            {
                ExpenseId = expenseId,
                Distance  = 1,
                From      = "From",
                To        = "To",
                Expense   = null,
            };

            await client.ExpenseTravelService.Add(expenseTravel);

            int actual = context.ExpenseTravels.Count();

            Assert.AreEqual(expected, actual);

            expenseTravel.From = Guid.NewGuid().ToString();
            await client.ExpenseTravelService.Update(expenseTravel);

            var actualUpdated = context.ExpenseTravels.Where(t => t.ExpenseId == expenseTravel.ExpenseId).FirstOrDefault();

            Assert.AreEqual(expenseTravel.From, actualUpdated.From);
        }
        public async Task TravelRequestService_AddTravelRequest_Added_NotFail_Test()
        {
            var context  = new Data.MyCompanyContext();
            int expected = context.TravelRequests.Count() + 1;

            var client        = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var employeeId    = context.Employees.FirstOrDefault().EmployeeId;
            var TravelRequest = new TravelRequest()
            {
                Name               = "Bussiness Travel",
                Description        = "Lorem ipsum dolor sit amet.",
                From               = "From",
                To                 = "To",
                Depart             = DateTime.UtcNow.AddDays(5),
                Return             = DateTime.UtcNow.AddDays(7),
                CreationDate       = DateTime.UtcNow.AddDays(-1),
                LastModifiedDate   = DateTime.UtcNow,
                AccommodationNeed  = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat",
                TransportationNeed = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat",
                Comments           = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat",
                RelatedProject     = "MyCompany",
                Status             = TravelRequestStatus.Approved,
                TravelType         = TravelType.Roundtrip,
                EmployeeId         = employeeId,
            };

            int travelRequestId = await client.TravelRequestService.Add(TravelRequest);

            int actual = context.TravelRequests.Count();

            Assert.AreEqual(expected, actual);
        }
        public async Task TravelRequestService_UpdateTravelRequest_NotFail_Test()
        {
            var context       = new Data.MyCompanyContext();
            var travelRequest = context.TravelRequests.FirstOrDefault(r => r.Employee.EmployeePictures.Any());
            var client        = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);

            var newTravelRequest = new TravelRequest()
            {
                TravelRequestId = travelRequest.TravelRequestId,
                Name            = travelRequest.Name,
                Description     = travelRequest.Description,
                From            = Guid.NewGuid().ToString(),
                To                 = travelRequest.To,
                Depart             = travelRequest.Depart,
                Return             = travelRequest.Return,
                CreationDate       = travelRequest.CreationDate,
                LastModifiedDate   = travelRequest.LastModifiedDate,
                AccommodationNeed  = travelRequest.AccommodationNeed,
                TransportationNeed = travelRequest.TransportationNeed,
                Comments           = travelRequest.Comments,
                RelatedProject     = travelRequest.RelatedProject,
                Status             = (TravelRequestStatus)(int)travelRequest.Status,
                TravelType         = (TravelType)(int)travelRequest.TravelType,
                EmployeeId         = travelRequest.EmployeeId,
            };

            await client.TravelRequestService.Update(newTravelRequest);

            var newContext = new Data.MyCompanyContext();
            var actual     = newContext.TravelRequests.FirstOrDefault(r => r.TravelRequestId == travelRequest.TravelRequestId);

            Assert.AreEqual(newTravelRequest.From, actual.From);
        }
Пример #4
0
        public async Task ExpenseService_AddExpense_Added_NotFail_Test()
        {
            var client   = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var context  = new Data.MyCompanyContext();
            int expected = context.Expenses.Count() + 1;

            var employeeId = context.Employees.FirstOrDefault().EmployeeId;
            var expense    = new Expense()
            {
                Name             = "Bussiness",
                Description      = "Lorem ipsum dolor sit amet.",
                CreationDate     = DateTime.UtcNow.AddDays(-1),
                LastModifiedDate = DateTime.UtcNow,
                Status           = ExpenseStatus.Approved,
                Amount           = 270,
                Contact          = "Jeff Phillips",
                Picture          = null,
                ExpenseType      = ExpenseType.Accommodation,
                RelatedProject   = "MyCompany",
                EmployeeId       = employeeId
            };
            await client.ExpenseService.Add(expense);

            int actual = context.Expenses.Count();

            Assert.AreEqual(expected, actual);
        }
        protected override Dialog OnCreateDialog(int id)
        {
            if (id == 1)
            {
                var factory         = LayoutInflater.From(this);
                var text_entry_view = factory.Inflate(Resource.Layout.Settings, null);

                var serverEdit = text_entry_view.FindViewById <EditText>(Resource.Id.server);
                serverEdit.Text = AppSettings.ApiUri.AbsoluteUri;

                var builder = new AlertDialog.Builder(this);
                builder.SetIconAttribute(Android.Resource.Attribute.AlertDialogIcon);
                builder.SetTitle("Settings");
                builder.SetView(text_entry_view);
                builder.SetPositiveButton("Save", (sender, args) =>
                {
                    AppSettings.ApiUri = new Uri(serverEdit.Text);
                    client             = new MyCompanyClient(AppSettings.ApiUri.ToString() + "noauth/", "test");
                    mainFragment.Model.InitializeData(client);
                });
                builder.SetNegativeButton("Cancel", (sender, args) =>
                {
                });

                return(builder.Create());
            }
            return(base.OnCreateDialog(id));
        }
Пример #6
0
        public async Task VisitService_UpdateStatus_Test()
        {
            var context = new Data.MyCompanyContext();
            int visitId = context.Visits.FirstOrDefault().VisitId;

            var client = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            await client.VisitService.UpdateStatus(visitId, DocumentResponse.VisitStatus.Arrived);
        }
        public async Task EmployeeService_GetEmployees_Test()
        {
            var client = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var result = await client.EmployeeService.GetEmployees();

            Assert.IsNotNull(result);
            Assert.AreNotEqual(0, result.Count);
        }
Пример #8
0
        public async Task VisitService_GetCount_Test()
        {
            var context  = new Data.MyCompanyContext();
            int expected = context.Visits.Count();
            var client   = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var actual   = await client.VisitService.GetCount(string.Empty, null, null);

            Assert.AreEqual(expected, actual);
        }
        public async Task EmployeeService_GetLoggedEmployeeInfo_Test()
        {
            var client = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var result = await client.EmployeeService.GetLoggedEmployeeInfo(PictureType.Small);

            Assert.IsNotNull(result);
            Assert.IsNotNull(result.EmployeePictures);
            Assert.IsTrue(result.EmployeePictures.Count() == 1);
        }
Пример #10
0
        public async Task VisitService_GetUserCount_Test()
        {
            var context  = new Data.MyCompanyContext();
            var employee = context.Employees.Include("Visits").Where(e => e.Visits.Any()).FirstOrDefault();
            var client   = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var actual   = await client.VisitService.GetUserCount(string.Empty, DateTime.Now.AddMonths(-1));

            Assert.AreEqual(employee.Visits.Count(), actual);
        }
        public async Task TravelRequestService_GetAllCount_Test()
        {
            var context = new Data.MyCompanyContext();
            int status  = (int)(TravelRequestStatus.Approved | TravelRequestStatus.Denied | TravelRequestStatus.Completed | TravelRequestStatus.Pending);

            var client = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var result = await client.TravelRequestService.GetAllCount(string.Empty, status);

            Assert.AreEqual(context.TravelRequests.Count(), result);
        }
Пример #12
0
        public async Task ExpenseService_GetTeamExpensesByMemberCount_Test()
        {
            var client          = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var context         = new Data.MyCompanyContext();
            var managerIdentity = context.Employees.FirstOrDefault(e => e.ManagedTeams.Any()).Email;

            var count = await client.ExpenseService.GetTeamExpensesByMemberCount();

            Assert.IsTrue(count > 0);
        }
Пример #13
0
        public async Task ExpenseService_GetTeamCount_NoResults_Test()
        {
            var client          = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var context         = new Data.MyCompanyContext();
            var managerIdentity = context.Employees.FirstOrDefault(e => e.ManagedTeams.Any()).Email;
            int expenseStatus   = (int)ExpenseStatus.Unknown;

            var count = await client.ExpenseService.GetTeamCount(expenseStatus);

            Assert.IsTrue(count == 0);
        }
        public async Task TravelRequestService_GetUserCount_Test()
        {
            var context  = new Data.MyCompanyContext();
            var employee = context.Employees.Include("Travels").FirstOrDefault(e => e.Travels.Any());
            int status   = (int)(TravelRequestStatus.Approved | TravelRequestStatus.Denied | TravelRequestStatus.Completed | TravelRequestStatus.Pending);

            var client = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var result = await client.TravelRequestService.GetUserCount(string.Empty, status);

            Assert.AreEqual(employee.Travels.Count(), result);
        }
        public async Task TravelRequestService_GetTeamTravelDistribution_Test()
        {
            var context  = new Data.MyCompanyContext();
            var employee = context.Employees.Where(e => e.ManagedTeams.Any()).FirstOrDefault();

            var client  = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var results = await client.TravelRequestService.GetTeamTravelDistribution();

            Assert.IsNotNull(results);
            Assert.IsTrue(results.Any());
        }
Пример #16
0
        public async Task ExpenseService_UpdateExpense_NotFail_Test()
        {
            var client    = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var context   = new Data.MyCompanyContext();
            var expenseId = context.Expenses.FirstOrDefault().ExpenseId;

            await client.ExpenseService.UpdateStatus(expenseId, ExpenseStatus.Denied);

            var actual = await client.ExpenseService.Get(expenseId, PictureType.Small);

            Assert.AreEqual(actual.Status, ExpenseStatus.Denied);
        }
Пример #17
0
        public async Task VisitService_GetCountFromDate_Test()
        {
            var      context = new Data.MyCompanyContext();
            DateTime date    = context.Visits.ToList().First().VisitDateTime;

            int expected = context.Visits.Count(v => v.VisitDateTime >= date);

            var client = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var actual = await client.VisitService.GetCountFromDate(string.Empty, date);

            Assert.AreEqual(expected, actual);
        }
Пример #18
0
        public async Task EmployeeService_GetEmployee_Test()
        {
            var client     = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var context    = new Data.MyCompanyContext();
            int employeeId = context.Employees.First().EmployeeId;

            var result = await client.EmployeeService.GetEmployee(employeeId, PictureType.Small);

            Assert.IsNotNull(result);
            Assert.IsNotNull(result.EmployeePictures);
            Assert.IsTrue(result.EmployeePictures.Count() == 1);
        }
Пример #19
0
        public async Task ExpenseService_GetUserCount_Test()
        {
            var client        = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var context       = new Data.MyCompanyContext();
            int expectedCount = context.Expenses.Count();
            var userIdentity  = context.Employees.FirstOrDefault(e => e.Expenses.Any()).Email;
            int expenseStatus = (int)(ExpenseStatus.Approved | ExpenseStatus.Denied | ExpenseStatus.Pending);

            var count = await client.ExpenseService.GetUserCount(expenseStatus);

            Assert.IsTrue(count > 0);
        }
        public async Task TravelAttachmentService_Get_Test()
        {
            var client = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);

            var context            = new Data.MyCompanyContext();
            var travelAttachmentId = context.TravelAttachments.FirstOrDefault().TravelAttachmentId;

            TravelAttachment travelAttachment = await client.TravelAttachmentService.Get(travelAttachmentId);

            Assert.IsNotNull(travelAttachment);
            Assert.AreEqual(travelAttachmentId, travelAttachment.TravelAttachmentId);
        }
        async Task Test()
        {
            AuthenticationContext authenticationContext = new AuthenticationContext("https://login.windows.net/mycompanysuite.onmicrosoft.com");

            AuthenticationResult result = await authenticationContext.AcquireTokenAsync("http://localhost:31329/", "http://localhost:31329/");

            // Create an OAuth2 Bearer token from the AssertionCredential
            //string accessToken = credential.CreateAuthorizationHeader();

            var service  = new MyCompanyClient("http://localhost:31329/", result.AccessToken);
            var employee = await service.EmployeeService.GetLoggedEmployeeInfo(PictureType.Small);
        }
Пример #22
0
        public async Task ExpenseService_GetTeamMemberExpensesByMonth_Test()
        {
            var client      = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var context     = new Data.MyCompanyContext();
            var employeeId  = context.Employees.FirstOrDefault(e => e.Expenses.Any()).EmployeeId;
            int expenseType = (int)(ExpenseType.Accommodation | ExpenseType.Food | ExpenseType.Other | ExpenseType.Travel);

            var results = await client.ExpenseService.GetTeamMemberExpensesByMonth(employeeId, expenseType);

            Assert.IsNotNull(results);
            Assert.IsTrue(results.Any());
        }
Пример #23
0
        public async Task ExpenseService_GetTeamMemberSummaryExpenses_EmptyMonth_Test()
        {
            var client  = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var context = new Data.MyCompanyContext();

            var employeeId = context.Employees.FirstOrDefault(e => e.Expenses.Any()).EmployeeId;
            var datetime   = context.Expenses.Where(e => e.EmployeeId == employeeId).First().CreationDate;

            var results = await client.ExpenseService.GetTeamMemberSummaryExpenses(employeeId, null, datetime.Year);

            Assert.IsNotNull(results);
            Assert.IsTrue(results.Any());
        }
Пример #24
0
        public async Task ExpenseService_GetTeamExpensesByMember_Test()
        {
            var         client          = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var         context         = new Data.MyCompanyContext();
            var         managerIdentity = context.Employees.FirstOrDefault(e => e.ManagedTeams.Any()).Email;
            PictureType pictureType     = PictureType.Small;

            var results = await client.ExpenseService.GetTeamExpensesByMember(pictureType);

            Assert.IsNotNull(results);
            Assert.IsTrue(results.Any());
            Assert.IsNotNull(results.First().Picture);
        }
        public async Task VisitorService_Get_Test()
        {
            var context   = new Data.MyCompanyContext();
            int visitorId = context.Visitors.FirstOrDefault().VisitorId;

            var client = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var result = await client.VisitorService.Get(visitorId, PictureType.Small);

            Assert.IsNotNull(result);
            Assert.IsNotNull(result.VisitorPictures);
            Assert.IsTrue(result.VisitorId == visitorId);
            Assert.IsTrue(result.VisitorPictures.Count == 1);
        }
Пример #26
0
        public async Task ExpenseService_GetUserExpenses_NoResults_Test()
        {
            var client        = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var context       = new Data.MyCompanyContext();
            var userIdentity  = context.Employees.FirstOrDefault(e => e.Expenses.Any()).Email;
            int expenseStatus = (int)ExpenseStatus.Unknown;
            int number        = 1;

            var results = await client.ExpenseService.GetUserExpenses(expenseStatus, number, 0);

            Assert.IsNotNull(results);
            Assert.IsFalse(results.Any());
        }
Пример #27
0
        public async Task VisitService_GetCount_Today_Test()
        {
            DateTime date   = DateTime.UtcNow.AddDays(2).Date;
            DateTime toDate = DateTime.UtcNow.AddDays(3).Date;

            var context  = new Data.MyCompanyContext();
            int expected = context.Visits.ToList().Where(v => v.VisitDateTime.Date == date).Count();

            var client = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var actual = await client.VisitService.GetCount(string.Empty, date, toDate);

            Assert.AreEqual(expected, actual);
        }
Пример #28
0
        public async Task ExpenseService_GetExpenseAllUserInfo_Call_GetResults_Test()
        {
            var client    = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var context   = new Data.MyCompanyContext();
            int expenseId = context.Expenses.FirstOrDefault().ExpenseId;

            var result = await client.ExpenseService.Get(expenseId, PictureType.Small);

            Assert.IsNotNull(result);
            Assert.IsNotNull(result.Employee);
            Assert.IsNotNull(result.Employee.EmployeePictures);
            Assert.IsTrue(result.Employee.EmployeePictures.Count() == 1);
            Assert.IsTrue(result.ExpenseId == expenseId);
        }
        public async Task TravelRequestService_GetNotFinishedUserTravelRequests_Test()
        {
            var context      = new Data.MyCompanyContext();
            var userIdentity = context.Employees.FirstOrDefault(e => e.Travels.Any()).Email;
            int status       = (int)(TravelRequestStatus.Approved | TravelRequestStatus.Denied | TravelRequestStatus.Completed | TravelRequestStatus.Pending);

            var client  = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var results = await client.TravelRequestService.GetNotFinishedUserTravelRequests(string.Empty, status);

            Assert.IsNotNull(results);
            Assert.IsTrue(results.Any());
            Assert.IsNotNull(results.First().Employee);
            Assert.IsNull(results.First().Employee.EmployeePictures);
        }
        public async Task TravelRequestService_GetCompleteInfo_Test()
        {
            var context         = new Data.MyCompanyContext();
            int travelRequestId = context.TravelRequests.FirstOrDefault().TravelRequestId;

            var client = new MyCompanyClient(SecurityHelper.UrlBase, SecurityHelper.AccessToken);
            var result = await client.TravelRequestService.Get(travelRequestId, PictureType.Small);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.TravelRequestId == travelRequestId);
            Assert.IsNotNull(result.Employee);
            Assert.IsNotNull(result.Employee.EmployeePictures);
            Assert.IsTrue(result.Employee.EmployeePictures.Count == 1);
        }