JC360® API help

      var userId = 1234567;
      var startDate = DateTime.UtcNow.Date;
      var endDate = startDate.AddDays(6);
      int holiday1Id;

      using (API api = new API())
      {
        api.AddHolidayForUser(AuthCode, userId, startDate, endDate, 480, null, out holiday1Id);
      }

var userId = 1234567;
var startDate = DateTime.UtcNow.Date;
var endDate = startDate.AddDays(6);
int holiday1Id;

using (API api = new API())
{
api.AddHolidayForUser(AuthCode, userId, startDate, endDate, true, null, null, out holiday1Id);
}

      var holidayCategoryId1 = 100;
      var holidayCategoryId2 = 101;
      var holidayCategoryId3 = 102;
      var holidayLimitToUpload = new HolidayLimit
      {
          UserId = 1234567,
          Year = 2013,
          CategoryLimits = new CategoryLimit[]
          {
              new CategoryLimit{ CategoryId = holidayCategoryId1, LimitInMins = 200},
              new CategoryLimit{ CategoryId = holidayCategoryId2, LimitInMins = 300},
              new CategoryLimit{ CategoryId = holidayCategoryId3, LimitInMins = 400}
          }
      };
      using (API api = new API())
      {
        api.AddHolidayLimitsForUser(AuthCode, holidayLimitToUpload);
      }

      using (var api = new API())
      {
        var targetUserId = 123;
        var authCode = Guid.NewGuid();
        var startDate = DateTime.UtcNow;
        var endDate = DateTime.UtcNow.AddHours(1);
        var taskId = 123456;
        var comment = "comment";

        var ret = api.AddManualWorkitem(authCode, targetUserId, startDate, endDate, taskId, comment);

        if (ret != AddManualWorkitemRet.OK)
          Console.WriteLine("Error getting adding manualworkitem for the user");
      }

      var userId = 1234567;
      var startDate = DateTime.UtcNow.Date;
      var endDate = startDate.AddDays(6);
      int sickLeave1Id;

      using (API api = new API())
      {
        api.AddSickLeaveForUser(AuthCode, userId, startDate, endDate, 480, out sickLeave1Id);
      }

      var userId = 1234567;
      var startDate = DateTime.UtcNow.Date;
      var endDate = startDate.AddDays(6);
      int sickLeave1Id;

      using (API api = new API())
      {
        api.AddSickLeaveForUser(AuthCode, userId, startDate, endDate, true, null, out sickLeave1Id);
      }

      using (API api = new API())
      {
          var ret = api.ApplyTemplate(AuthCode, template1Id, project1, true);

          if (ret != ApplyTemplateRet.OK)
              Console.WriteLine("Error applying template (id: {0}) to project (id: {1}), error code: {2}", template1Id, project1, ret);
      }

      int[] TaskIdList = { Work1Id, Work2Id };
      int[] UserIdList = { Worker1UserId, Worker2UserId };

      using (API api = new API())
      {
          var ret = api.AssignUsersToTasks_v4(AuthCode, TaskIdList, UserIdList, 200, new DateTime(2013, 1, 1), new DateTime(2013, 1, 1));

          if (ret != AssignUsersToTasksRet_v4.OK)
              Console.WriteLine("Error assigning users to tasks, error code: {0}", ret);
      }

      using (var api = new API())
      {
      var userId = 123;
      var groupId = 123;
      var authCode = Guid.NewGuid();

      var ret = api.AssignUserToWorkerGroups(authCode, userId, new[] { groupId })

      if (ret != AssignUserToWorkerGroupsRet.OK)
        Console.WriteLine("Error assigning user to workergroups");
      }

      using (var api = new API())
      {
          var ret = api.CloseTask(AuthCode, task1Id);

          if (ret != CloseTaskRet.OK)
              Console.WriteLine("Error closing task (id: {0}), error code: {1}", task1Id, ret);
      }

      var billingInformation = new BillingInformation_v2
      {
          CostCenterId = 1,
          CompanyName = "TestCompanyName",
          TaxNumber = "87654321",
          City = "City",
          Zip = "Zip",
          StreetName = "StreetName",
          StreetType = "StreetType",
          Number = "11",
          Floor = "22",
          Door = "33",
          ExtId = "TC5698",
      };

      var costCenter = new CostCenter_v2
      {
          Id = 1,
          Description = "Default cost center",
          Name = "Default",
          IsDefault = true,
          BillingInformation = billingInformation,
      };

      using (var api = new API())
      {
          var ret = api.CreateCostCenter_v2(AuthCode, costCenter);

          if (ret != CostCenterCreateError.OK)
          {
              Console.WriteLine("Error creating cost center, error code: {0}", ret);
          }
      }

      using (var api = new API())
      {
          var ret = api.CreateIssue(AuthCode, "issueCode", "company", "subject", IssueState.Opened, new DateTime(2018, 1, 15, 15, 0, 0), 1, new DateTime(2018, 1, 15, 16, 0, 0), 1);

          if (ret != CreateIssueRet.OK)
              Console.WriteLine("Error creating issue, error code: {0}", ret);
      }

      int RootTaskID = 1111; // get your own from GetTaskHierarchy call

      // Create a project and not assigning to anyone
      int project1Id;
      using (API api = new API())
      {
        api.CreateProject_v2(AuthCode, RootTaskID, "Project1", null, null, null, null, null, null, null, null, out project1Id);
      }

      // Create a project under the newly created project and assigning to someone
      var participants = new ProjectParticipant[]
      {
        new ProjectParticipant { UserId = Worker1UserId, IsLeader = true },
        new ProjectParticipant { UserId = Worker2UserId, IsLeader = false }
      };

      int project2Id;
      using (API api = new API())
      {
        api.CreateProject_v2(AuthCode, project1Id, "Project2", participants, null, null, null, null, null, null, null, out project2Id);
      }
      
      // Create a project with all values set
      int project3Id;
      using (API api = new API())
      {
         api.CreateProject_v2(AuthCode, 
                              project1Id,    // create project under "Project1" project
                              "Project3",    // project's name
                              participants, 
                              "description", 
                              2 * 60, // estimated time is 2 hours
                              new DateTime(2013, 1, 1),  // Project should start in 2013. Jan. 01
                              new DateTime(2013, 2, 1),  // Project's deadline is 2013. Feb. 01
                              1000,  // project's estimated cost should be 1000 unit (e.g. usd, eur)
                              null,  // taxId, legacy field, leave null by default 
                              150,   // set priority 150 for project
                              out project3Id);
      }

      using (API api = new API())
      {
        var ret = api.CreateProjectMembership(AuthCode, 2, 456, false);
      }

      if (ret != CreateProjectMembershipRet.OK)
      {
        Log("Create project membership error: " + ret);
      }

      using (var api = new API())
      {
          int createdUserId;
          var ret = api.CreateUser(AuthCode, 123, "firstname", "lastname", "test@test.com", UserAccessLevel.Administrator, "en-US", true, true, null, null, null, out createdUserId);
          if (ret != CreateUserRet.OK)
            Console.WriteLine("Error creating User")
      }

      using (var api = new API())
      {
        var companyRootGroupId = 123;
        var authCode = Guid.NewGuid();

        int createdUserGroupId;
        var ret = api.CreateUserGroup(authCode, companyRootGroupId, "Group1", null, out createdUserGroupId);
        if (ret != CreateUserGroupRet.OK)
          Console.WriteLine("Error creating Group");
      }

      int Project1Id = 1111; // Get your ProjectId from GetTaskHierarchy or from a preceeding CreateProject call

      // Create a work and not assigning to anyone
      int work1Id;
      using (API api = new API())
      {
        api.CreateWork_v4(AuthCode, Project1Id, "Work1", null, false, null, null, null, null, null, null, null, out work1Id);
      }

      // Create a work and assigning to someone
      int work2Id;
      using (API api = new API())
      {
        api.CreateWork_v4(AuthCode, Project1Id, "Work2", "Description",
          false,  // should not assign to existing project participants
          new int[] { Worker1UserId },  // assign to a worker
          200,  // assignment priority should be 200
          new DateTime(2013, 1, 1),  // StartDate should be the same day as EndDay, so user has only 1 day to finish with its task
          new DateTime(2013, 1, 1),
          4 * 60,   // Planned time is 4 hours
          72,     // Close task automatically after worker didn't work on it for 72 hours
          new RequiredCloseReasons_v4
          {
            AfterTimeInMins = 5 * 60,
            AfterDate = new DateTime(2013, 1, 2),
            RepeatIntervalInMins = 60,
            RepeatingTimes = 3
          };
          out work2Id);
      }

      var targetUserId = 123;

      var schedule = new WorktimeSchedule
      {
      Id = 0,
      LocalDay = new DateTime(2018, 10, 19),
      UserId = targetUserId,
      IsInOffice = false
      };

      var items = new List<WorktimeScheduleItem>()
      {
      new WorktimeScheduleItem
      {
      UtcStartDate = DateTime.UtcNow.LocalDay.AddHours(6),
      UtcEndDate = DateTime.UtcNow.LocalDay.AddHours(8),
      TaskId = 1234,
      IsOvertime = false,
      }
      };

      schedule.Items = items.ToArray();

      int createdId;
      using (API api = new API())
      {
      var ret = api.CreateWorktimeSchedule(AuthCode, schedule, out createdId);
      if (ret != CreateWorktimeScheduleRet.OK)
      Console.WriteLine("Error creating WorktimeSchedule")
      }

      var targetUserId = 123;

      var schedule = new WorktimeSchedule_v2
      {
      Id = 0,
      LocalDay = new DateTime(2018, 10, 19),
      UserId = targetUserId,
      IsInOffice = false,
      IsWorkDay = true
      };

      var items = new List<WorktimeScheduleItem_v2>()
      {
      new WorktimeScheduleItem_v2
      {
      UtcStartDate = DateTime.UtcNow.LocalDay.AddHours(6),
      UtcEndDate = DateTime.UtcNow.LocalDay.AddHours(8),
      TaskId = 1234,
      IsOvertime = false,
      CategoryId = 5678
      }
      };

      schedule.Items = items.ToArray();

      int createdId;
      using (API api = new API())
      {
      var ret = api.CreateWorktimeSchedule_v2(AuthCode, schedule, out createdId);
      if (ret != CreateWorktimeScheduleRet_v2.OK)
      Console.WriteLine("Error creating WorktimeSchedule")
      }

      using (var api = new API())
      {
      var userId = 123;
      var groupId = 123;
      var authCode = Guid.NewGuid();

      var ret = api.DeassignUserFromWorkerGroups(authCode, userId, new[] { groupId })

      if (ret != DeassignUserFromWorkerGroups.OK)
      Console.WriteLine("Error deassigning user from workergroups");
      }

      int[] TaskIdList = new int[] { Work1Id, Work2Id };
      int[] UserIdList = new int[] { Worker1UserId, Worker2UserId };

      using (API api = new API())
      {
        var ret = api.DeassignUsersFromTasks(AuthCode, TaskIdList, UserIdList)
            
        if (ret != DeassignUsersFromTasksRet.OK)
        {
          Log("Remove assignment error: " + ret);
        }
      }

       using (API api = new API())
       {
            var result = api.DeleteDictionaryAutoRule(AuthCode, dictionaryAutoRule.Id);
       }

      var holiday1Id = 123;
      using (API api = new API())
      {
        api.DeleteHoliday(AuthCode, holiday1Id);
      }

      using (var api = new API())
      {
        var authCode = Guid.NewGuid();
        var manualWorkitemId = 123456;

        var ret = api.DeleteManualWorkitem(authCode, manualWorkitemId);

        if (ret != DeleteManualWorkitemRet.OK)
          Console.WriteLine("Error deleting manualworkitem");
      }

      var sickLeave1Id = 123;
      using (API api = new API())
      {
        api.DeleteSickLeave(AuthCode, sickLeave1Id);
      }

      using (var api = new API())
      {
      var ret = api.DeleteUser(AuthCode, 123);
      if (ret != DeleteUserRet.OK)
      Console.WriteLine("Error deleting User")
      }

      using (var api = new API())
      {
        var groupId = 123;
        var authCode = Guid.NewGuid();

        var ret = api.DeleteUserGroup(authCode, groupId);
        if (ret != DeleteUserGroupRet.OK)
          Console.WriteLine("Error deleting Group");
      }

      int worktimeScheduleId = 123;
      using (API api = new API())
      {
      var ret = api.DeleteWorktimeSchedule(AuthCode, worktimeScheduleId);
      if (ret != DeleteWorktimeScheduleRet.OK)
      Console.WriteLine("Error deleting WorktimeSchedule")
      }

      int dataSourceId = 123456789;
      byte[] fileContent;
      using (API api = new API())
      {
        api.DownloadDataSourceFile(AuthCode, dataSourceId, out fileContent);
      }

      ProcessExcelFile(fileContent);

      using (var api = new API())
      {
      
        var authCode = Guid.NewGuid();
        var queryStartDate = new DateTime(2022,02,01);
        var queryEndDate = new DateTime(2022,02,28);
        byte[] excel;
        var ret = api.ImportLeavesAndSchedulesFromExcel(authCode, UserIdentifierType.ExtId, queryStartDate, queryEndDate, out excel);

        if (ret != ImportLeavesAndSchedulesFromExcelRet.OK)
          Console.WriteLine("Error exporting leaves and schedules");
      }

using (var api = new API())
{
            var projectId = 123;
            var authCode = Guid.NewGuid();
            
            Task_v4 subTreeRoot;
            var ret = api.ExportTaskSubTree(authCode, projectId, out subTreeRoot);
            if (ret != ExportTaskSubTreeRet.OK)
                Console.WriteLine("Error querying the subhierarchy");
}

      using (var api = new API())
      {
        WorkerGroup_v2[] userGroups;
        var ret = api.GetAllUserGroups(authCode, false, out userGroups);
        if (ret != GetAllUserGroupsRet.OK)
          Console.WriteLine("Error getting user groups")
      }

      using (var api = new API())
      {
        Worker_v2[] workers;
        var ret = api.GetAllUsers(AuthCode, false, out workers);
        if (ret != GetAllUsersRet.OK)
          Console.WriteLine("Error getting users")
      }

      var userIds = new[] { Worker1UserId };

      using (var api = new API())
      {
          Holiday[] holidays;
          var ret = api.GetApprovableHolidayRequests(AuthCode, userIds, out holidays);
            
          if (ret != GetApprovableHolidayRequestsRet.OK)
          {
              Console.WriteLine("Get approvable holiday request error: {0}", ret);
          }
          else
          {
              foreach (var h in holidays)
              { 
                  Console.WriteLine(string.Format("UserId: {0}, StartDate: {1}, EndDate: {2}, CategoryId: {3}, Daily duration: {4}, Number of workdays: {5}, Approved by: {6}, LastChangedAt: {7}", 
                      h.UserId, h.StartDate, h.EndDate, h.HolidayCategoryId, h.DailyDurationInMins, h.NumberOfWorkDays, h.ApprovedBy, h.LastChangedAt));
              }
          }
      }

      var userIds = new[] { Worker1UserId };

      using (var api = new API())
      {
          WorktimeModification[] worktimeModifications;
          var ret = api.GetApprovableWorktimeModificationRequests(AuthCode, userIds, out worktimeModifications);
            
          if (ret != GetApprovableWorktimeModificationRequestsRet.OK)
          {
              Console.WriteLine("Get approvable modification request error: {0}", ret);
          }
          else
          {
              foreach (var wm in worktimeModifications)
              {
                  Console.WriteLine("Id: {0}, Type: {1}, TaskId: {2}, StartDate: {3}, EndDate: {4}, UserId: {5}, Comment: {6}, CreateDate: {7}", 
                      wm.Id, wm.Type, wm.WorkId.ToString() ?? "", wm.StartDate, wm.EndDate, wm.UserId, wm.Comment, wm.CreateDate);
              }                    
          }
      }

      using (var api = new API())
      {
      var groupId = 123;
      var authCode = Guid.NewGuid();

      int[] userIds;
      var ret = api.GetAssignedSupervisorsToWorkerGroup(authCode, groupId, out userIds);

      if (ret != GetAssignedSupervisorsToWorkerGroupRet.OK)
        Console.WriteLine("Error getting users assigned to worker group");
      }

      // Get a project and its child works (include itself but without closed tasks/assignments)
      using (API api = new API())
      {
          Assert.AreEqual(api.GetChildrenForTask(AuthCode, Project1Id, true, false, out childTasks), GetChildrenForTaskRet.OK);
      }
      
      var project1 = childTasks.FirstOrDefault(t => t.Id == Project1Id);
      var work1 = childTasks.FirstOrDefault(t => t.Id == Work1Id);
      

      using (var api = new API())
      {
          DataCollectorDefinition[] definitions;
          var ret = api.GetCompanyDataCollectorReportDefinitions(AuthCode, out definitions);

          if (ret != GetCompanyDataCollectorReportDefinitionsRet.OK)
          {
              Console.WriteLine("Error getting company data collector defintions: {0}", ret);
          }
          else
          {
              foreach (var definition in definitions)
              {
                  Console.WriteLine("Id: {0}, Name: {1}, Description: {2}", definition.Id, definition.Name, definition.Description);
              }
          }
      }

      DictionaryAutoRuleSample[] dictionaryAutoRuleSamples;
      
      using (API api = new API())
      {
          var result = api.GetCompanyDictionaryAutoRuleSamples(AuthCode, out dictionaryAutoRuleSamples);
      }

      using (var api = new API.API())
      {
        var costCenters = api.GetCostCenters_v2(AuthCode);

        foreach (var costCenter in costCenters)
        {
          Console.WriteLine("Cost center id: {0}, Cost center name: {1}, Cost center ext id: {2}, Default cost center: {3}, Description: {4}, Cost center billing information company name: {5}, Cost center billing information city: {6}",
            costCenter.Id, costCenter.Name, costCenter.ExtId, costCenter.IsDefault, costCenter.Description, 
            costCenter.BillingInformation != null ? costCenter.BillingInformation.CompanyName : "", 
            costCenter.BillingInformation != null ? costCenter.BillingInformation.City : "");
        }
      }

      DateTime startDate = new DateTime(2017, 1, 10);
      DateTime endDate = new DateTime(2017, 1, 11);

      using (var api = new API())
      {
          DailyWorktimeReport report;
          var ret = api.GetDailyWorktimeReport(AuthCode, startDate, endDate, null, null, null, out report);

          if (ret != GetDailyWorktimeReportRet.OK)                
              Console.WriteLine("Error getting daily worktime report, error code: {0}", ret);                
      }

      var startDate = new DateTime(2015, 10, 1);
      var endDate = new DateTime(2015, 10, 2);

      using (var api = new API())
      {
          DataCollectorReport report;
          var ret = api.GetDataCollectorReport(AuthCode, startDate, endDate, null, null, definitionId, 120, out report);

          if (ret != GetDataCollectorReportRet.OK)
          {
              Console.WriteLine("Error getting data collector report, Id {0}, error code: {1}", definitionId, ret);
          }
          else
          {
              Console.WriteLine("Listing report content information for {0} result sets:", report.ResultSet.Tables.Length);
              foreach (var dataTable in report.ResultSet.Tables)
              {
                  Console.WriteLine("Result set name: {0}", dataTable.TableName);
                  Console.WriteLine("The dataset has {0} column(s) and {1} row(s)", dataTable.Columns.Length, dataTable.Rows.Length);

                  if (dataTable.Hide.HasValue && dataTable.Hide.Value)                        
                      Console.WriteLine("The dataset should be hidden when rendering the output for user");
                  else                        
                      Console.WriteLine("The dataset should be shown when rendering the output for user");

                  Console.WriteLine(dataTable.Delete ? "The dataset should be deleted before rendering the output for user" : "The dataset should not be deleted when rendering the output for user");
              }
          }
      }

      using (var api = new API())
      {
          UserEffectiveSetting[] effectiveSettings;
          var ret = api.GetEffectiveSettingsForUsers(AuthCode, new[] { Worker1UserId }, out effectiveSettings);

          if (ret != GetEffectiveSettingsForUsersRet.OK)
          {
              Console.WriteLine("Error getting effective settings, error code: {0}", ret);
          }
          else
          {
              foreach (var es in effectiveSettings)
              {
                  Console.WriteLine("Effective settings for UserId: {0}\n", es.UserId);

                  var ces = es.CoreTime;

                  Console.WriteLine("Coretime settings:");
                  Console.WriteLine("Core time start: {0},\nCore time finish: {1},\nMinimum worktime during coretime: {2},\nLatest start: {3} (mins),\nEarliest finish: {4} (mins)\n", 
                      TimeSpan.FromMinutes(ces.StartTime), 
                      TimeSpan.FromMinutes(ces.EndTime), 
                      TimeSpan.FromMinutes(ces.MinimumWorkTime), 
                      ces.StartOffset, 
                      ces.EndOffset);

                  var cles = es.Client;

                  var ruleRestrictions = new List<string>();

                  if (cles.RuleRestrictions.HasFlag(RuleRestrictions.CannotOverrideRules))
                      ruleRestrictions.Add("RuleRestrictionsCannotOverrideRules");

                  if (cles.RuleRestrictions.HasFlag(RuleRestrictions.CannotCreateOrModifyRules))
                      ruleRestrictions.Add("RuleRestrictionsCannotCreateOrModifyRules");

                  if (cles.RuleRestrictions.HasFlag(RuleRestrictions.CannotCreateOrModifyRules) && cles.RuleRestrictions.HasFlag(RuleRestrictions.CanModifyRuleTitle))
                      ruleRestrictions.Add("RuleRestrictionsCanModifyRuleTitle");

                  if (cles.RuleRestrictions.HasFlag(RuleRestrictions.CannotUseAnyOkValueForLearningRule))
                      ruleRestrictions.Add("RuleRestrictionsCannotUseAnyOkValueForLearningRule");

                  if (cles.RuleRestrictions.HasFlag(RuleRestrictions.CannotUseAnyOkValueForLearningRule) && cles.RuleRestrictions.HasFlag(RuleRestrictions.CanUseOkDefault))
                      ruleRestrictions.Add("RuleRestrictionsCanUseOkDefault");

                  if (cles.RuleRestrictions.HasFlag(RuleRestrictions.CannotUseAnyOkValueForLearningRule) && cles.RuleRestrictions.HasFlag(RuleRestrictions.CanUseOkUntilWindowClosed))
                      ruleRestrictions.Add("RuleRestrictionsCanUseOkUntilWindowClosed");

                  if (cles.RuleRestrictions.HasFlag(RuleRestrictions.CannotUseAnyOkValueForLearningRule) && cles.RuleRestrictions.HasFlag(RuleRestrictions.CanUseOkForOneHour))
                      ruleRestrictions.Add("RuleRestrictionsCanUseOkForOneHour");

                  if (cles.RuleRestrictions.HasFlag(RuleRestrictions.CannotUseAnyOkValueForLearningRule) && cles.RuleRestrictions.HasFlag(RuleRestrictions.CanUseOkForOneDay))
                      ruleRestrictions.Add("RuleRestrictionsCanUseOkForOneDay");

                  Console.WriteLine("Client settings:");
                  Console.WriteLine("Business hours: {0} - {1},\nLongest inactivity during business hours: {2},\nLongest inactivity outsider business hours: {3},\n" +
                                    "Longest offline work triggered by inactivity: {4}\nAd-hoc offline work maximum length: {5}\n" +
                                    "Rule restrictions: {6}\nScreenshot quality: {7},\n" +
                                    "Microsoft Internet Explorer® waiting time threshold: {8} (ms),\nMax offline workitems: {9}\nMultiple device login: {10},\n" +
                                    "Default task: {11},\n" +
                                    "Use email subjects for generating unique mail identifier into the incoming and outgoing mails: {12}\n", 
                      TimeSpan.FromMinutes(cles.WorktimeStartInMins), 
                      TimeSpan.FromMinutes(cles.WorktimeEndInMins),
                      TimeSpan.FromMinutes(cles.DuringWorkTimeIdleInMins),
                      TimeSpan.FromMinutes(cles.AfterWorktimeIdleInMins),
                      TimeSpan.FromMilliseconds(cles.DuringWorkTimeIdleManualIntervalInMilisec),
                      TimeSpan.FromMilliseconds(cles.MaxManualMeetingIntervalInMilisec),
                      ruleRestrictions.Count > 0 ? string.Join(", ", ruleRestrictions) : "Not set",
                      cles.ScreenshotQuality,
                      cles.BusyTimeThreshold,
                      cles.MaxOfflineWorkItems,
                      cles.CoincidentalClientsEnabled,
                      cles.DefaultTaskId,
                      cles.IsOutlookAddinMailTrackingUseSubject);

                  var mes = es.Meeting;

                  Console.WriteLine("Meeting settings:");
                  Console.WriteLine("Synchronization of Microsoft Office Outlook® created meetings: {0},\nSynchronization of IBM (Lotus) Notes created meetings: {1}\n" +
                                    "Default meeting task: {2},\nMandatory offline work subject: {3},\n" +
                                    "Offline work requested automatically (calendar): {4},\nSyncronize meeting updates: {5},\nOffline work time longer than or equal to 24 hours can be approved: {6},\n" +
                                    "Retain overlapping working time: {7},\nSynchronization of tentative meetings: {8}\n",  
                      mes.EnableMeetingTracking, 
                      mes.EnableLotusNotesMeetingTracking, 
                      mes.DefaultTaskId.HasValue ? mes.DefaultTaskId.Value.ToString() : "Not set", 
                      mes.IsMeetingSubjectMandatory, 
                      mes.IsOfflineWorkingTimeRequestAutomatic, 
                      mes.SynchronizeCalendarMeetingModifications,
                      mes.AllowApprovalOfMeetingsLongerOrEqualThan24Hours,
                      mes.KeepMeetingParallelWorktime,
                      mes.AreTentativeMeetingsSynched);

                  var moes = es.Mobile;

                  Console.WriteLine("Mobile settings:");
                  Console.WriteLine("Record locations: {0},\nMaximum length of private call in active time: {1},\nInactivity triggered logout (outside working time): {2}\n" +
                                    "Longest conversation without administration (multiple device login): {3}\n", 
                      moes.LocationTrackMode,
                      TimeSpan.FromMinutes(moes.PrivateCallDuration),
                      TimeSpan.FromMinutes(moes.AfterWorkTimeIdleMinutes),
                      TimeSpan.FromMinutes(moes.WorkCallDuration));

                  var ies = es.IncidentManager;

                  Console.WriteLine("Incident manager settings are not listed as this function is obsolete, only kept for backward compatibility.\n");

                  var oes = es.Other;

                  var taskMandatoryFields = new List<string>();

                  if (oes.TaskMandatoryFields.HasFlag(TaskMandatoryFields.Priority))
                      taskMandatoryFields.Add("TaskMandatoryFieldPriority");

                  if (oes.TaskMandatoryFields.HasFlag(TaskMandatoryFields.StartEndDate))
                      taskMandatoryFields.Add("TaskMandatoryFieldStartEndDate");

                  if (oes.TaskMandatoryFields.HasFlag(TaskMandatoryFields.PlannedWorkTime))
                      taskMandatoryFields.Add("TaskMandatoryFieldPlannedWorkTime");                        

                  if (oes.TaskMandatoryFields.HasFlag(TaskMandatoryFields.Description))
                      taskMandatoryFields.Add("TaskMandatoryFieldDescription");

                  if (oes.TaskMandatoryFields.HasFlag(TaskMandatoryFields.Category))
                      taskMandatoryFields.Add("TaskMandatoryFieldCategory");

                  var taskAssignmentMandatoryFields = new List<string>();

                  if (oes.TaskAssignmentMandatoryFields.HasFlag(AssignmentMandatoryFields.StartEndDate))
                      taskAssignmentMandatoryFields.Add("TaskAssignmentMandatoryFieldStartEndDate");

                  if (oes.TaskAssignmentMandatoryFields.HasFlag(AssignmentMandatoryFields.PlannedWorkTime))
                      taskAssignmentMandatoryFields.Add("TaskAssignmentMandatoryFieldPlannedWorkTime");

                  Console.WriteLine("Other settings:");
                  Console.WriteLine("Cost center id: {0},\nTime zone id: {1},\nCalendar id: {2},\nDaily working time: {3},\n" +
                                    "Mandatory task/project attributes: {4},\nMandatory task assignment attributes: {5},\n" +
                                    "Deadline for modifying working time: {6} (hours),\nMinimum number of active users in group: {7},\nMinimum percent of active users in group: {8}\n", 
                      oes.CostCenterId, 
                      oes.TimeZoneId, 
                      oes.CalendarId,
                      TimeSpan.FromMinutes(oes.DailyWorkTimeInMinutes),
                      taskMandatoryFields.Count > 0 ? string.Join(", ", taskMandatoryFields) : "Not set",
                      taskAssignmentMandatoryFields.Count > 0 ? string.Join(", ", taskAssignmentMandatoryFields) : "Not set",
                      oes.ManualWorkItemEditAgeLimit, 
                      oes.MinNumOfActiveUsersInGroup, 
                      oes.MinPercentOfActiveUsersInGroup);
              }
          }
      }

      var parameterId = 1234;

      using (var api = new API())
      {
          DataCollectorReport report;
          var ret = api.GetFavoriteCustomReport(AuthCode, parameterId, out report);

          if (ret != GetFavoriteCustomReportRet.OK)
          {
              Console.WriteLine("Error getting report, Id {0}, error code: {1}", parameterId, ret);
          }
          else
          {
              Console.WriteLine("Listing report content information for {0} result sets:", report.ResultSet.Tables.Length);
              foreach (var dataTable in report.ResultSet.Tables)
              {
                  Console.WriteLine("Result set name: {0}", dataTable.TableName);
                  Console.WriteLine("The dataset has {0} column(s) and {1} row(s)", dataTable.Columns.Length, dataTable.Rows.Length);

                  if (dataTable.Hide.HasValue && dataTable.Hide.Value)                        
                      Console.WriteLine("The dataset should be hidden when rendering the output for user");
                  else                        
                      Console.WriteLine("The dataset should be shown when rendering the output for user");

                  Console.WriteLine(dataTable.Delete ? "The dataset should be deleted before rendering the output for user" : "The dataset should not be deleted when rendering the output for user");
              }
          }
      }

      HolidayCategory[] holidayCategories;
      using (API api = new API())
      {
        api.GetHolidayCategories(AuthCode, out holidayCategories);
      }

      // find the holiday category you want and process it
      var holidayCategory = holidayCategories.First();
      int holidayCategoryId = holidayCategory.Id;
      string RGBColorCode = holidayCategory.RGBColorCode;   // e.g. "ffffff"
      string name = holidayCategory.Name;   // e.g. "Study Leave"
      bool paid = holidayCategory.Paid;   // e.g. true
      byte rank = holidayCategory.Rank;   // e.g. 1
      bool requestable = holidayCategory.Requestable;   //e.g. true

      var userId = 1234567;
      HolidayLimit[] holidayLimits;
      using (API api = new API())
      {
        api.GetHolidayLimitsOfUser(AuthCode, userId, out holidayLimits);
      }

      Holiday[] holidays;
      using (API api = new API())
      {
          var ret = api.GetHolidaysForCompany(AuthCode, out holidays);

          if (ret == GetHolidaysForCompanyRet.OK && holidays.Length > 0)
          { 
              // find the holiday you want and process it
              var holiday = holidays.First();
              var dailyDurationInMins = holiday.DailyDurationInMins; //e.g. 8 * 60
              var approvedBy = holiday.ApprovedBy;  // null or approverId
              var userId = holiday.UserId;  // UserId of a worker
              var startDate = holiday.StartDate;    // new DateTime(2014, 1, 2)
              var endDate = holiday.EndDate;    // new DateTime(2014, 1, 3)
              var holidayCategoryId = holiday.HolidayCategoryId;  // null or an existing holidayCategoryId
              var numberOfWorkDays = holiday.NumberOfWorkDays;    // 2 days
          }
      }

      Holiday[] holidays;
      using (API api = new API())
      {
        api.GetHolidaysOfUser(AuthCode, Worker1UserId, out holidays);
      }

      // find the holiday you want and process it
      var holiday = holidays.First();
      var dailyDurationInMins = holiday.DailyDurationInMins; //e.g. 8 * 60
      var approvedBy = holiday.ApprovedBy;  // null or approverId
      var userId = holiday.UserId;  // UserId of a worker
      var startDate = holiday.StartDate;    // new DateTime(2014, 1, 2)
      var endDate = holiday.EndDate;    // new DateTime(2014, 1, 3)
      var holidayCategoryId = holiday.HolidayCategoryId;  // null or an existing holidayCategoryId
      var numberOfWorkDays = holiday.NumberOfWorkDays;    // 2 days

      using (var api = new API())
      {
        var authCode = Guid.NewGuid();
        var targetUserId = 123456;
        var startDateInUtc = DateTime.UtcNow.AddMonths(-1);
        var endDateInUtc = DateTime.UtcNow;
        ManualWorkItem[] manualWorkitemsOfUser;

        var ret = api.GetManualWorkitemsOfUser(AuthCode, targetUserId, startDateInUtc, endDateInUtc, out manualWorkitemsOfUser);

        if (ret != GetManualWorkitemsRet.OK)
          Console.WriteLine("Error getting manualworkitems of the user");
        else
        {
          foreach (var manualWorkitem in manualWorkitemsOfUser)
          {
            Console.WriteLine($"Id: {manualWorkitem.Id} ManualWorkItemType: {manualWorkitem.ManualWorkItemType.ToString()}, TaskId: {manualWorkitem.TaskId} StartDate: {manualWorkitem.StartDate} EndDate: {manualWorkitem.EndDate} UserId: {manualWorkitem.UserId} Comment: {manualWorkitem.Comment} CreateDate: {manualWorkitem.CreateDate} CreatedBy: {manualWorkitem.CreatedBy}");
          }
        }
      }

      TaskHierarchy_v2 modifiedhierarchy;
      using (API api = new API())
      {
        // get all the tasks by passing 0 as version
        api.GetModifiedTasks_v2(AuthCode, 0, 0, out modifiedhierarchy);
      }
      
      var someProject = modifiedhierarchy.Root.Children[0];
      var someWork = someProject.Children[0];
      var someAssignment = someWork.AssignedTo[0];
      
      var lastTaskVersion = GetGreatestTaskVersion(modifiedhierarchy);
      var lastTaskAssignmentVersion = GetGreatestTaskAssignmentVersion(modifiedhierarchy);
      
      // get modified tasks an hour later...
      using (API api = new API())
      {
        // get only the changed tasks since the last check by passing the last version numbers
        api.GetModifiedTasks_v2(AuthCode, lastTaskVersion, lastTaskAssignmentVersion, out modifiedhierarchy);
      }

      OrganizationHierarchy hierarchy;
      Guid AuthCode = Guid.Parse("YourCompanyAuthCodeHere");
      using (API api = new API())
      {
        api.GetOrganizationHierarchy(AuthCode, false, out hierarchy);
      }

      // traverse hierarchy and export them to external system
      var rootGroup = hierarchy.Root as as RootWorkerGroup;
      var group1 = rootGroup.Children[0] as WorkerGroup;
      var user1 = group1.Children[0] as Worker;

      using (var api = new API())
      {
          PlanningPeriod[] planningPeriods;
          var ret = api.GetPlanningPeriods(AuthCode, out planningPeriods);

          if (ret != GetPlanningPeriodsRet.OK)
          {
              Console.WriteLine("Error getting planning periods for the company, error code is {0}", ret);
          }
          else
          {
              foreach (var pp in planningPeriods)
              {
                  Console.WriteLine("Period id: {0}, period name: {1}, period start date: {2}, period end date: {3}, is default: {4}", pp.PeriodId, pp.Name, pp.StartDate, pp.EndDate, pp.IsDefault);
              }
          }
      }

      using (var api = new API())
      {
          PlanningPeriod[] planningPeriods;
          var ret = api.GetPlanningPeriods(AuthCode, out planningPeriods);

          if (ret != GetPlanningPeriodsRet.OK)
          {
              Console.WriteLine("Error getting planning periods for the company, error code is {0}", ret);
          }
          else
          {
              foreach (var pp in planningPeriods)
              {
                  Console.WriteLine("Period id: {0}, period name: {1}, period start date: {2}, period end date: {3}, is default: {4}", pp.PeriodId, pp.Name, pp.StartDate, pp.EndDate, pp.IsDefault);
              }
          }
      }

      DateTime startDate = new DateTime(2013, 1, 10);
      DateTime endDate = new DateTime(2013, 1, 15);
      ProjectReportHierarchy_v2 report;

      // get the report
      using (API api = new API())
      {
        api.GetProjectReport_v2(AuthCode, startDate, endDate, null, null, out report);
      }

      // get root of the hierarchy (company-wide total costs and times)
      var totalTime = report.Root.TotalTime;     // value in ms;
      var totalCost = report.Root.InnerTotalCost;

      // get a containing project (Type is ProjectReportItemType.Project, has no UserId defined)
      var projectId = report.Root.Children[0].TaskId;
      var projectTotalTime = report.Root.Children[0].TotalTime;     // value in ms;
      var projectTotalCost = report.Root.Children[0].InnerTotalCost;

      // get a containing work in project (Type is ProjectReportItemType.Work, has no UserId defined)
      var workId = report.Root.Children[0].Children[0].TaskId;
      var workTotalTime = report.Root.Children[0].Children[0].TotalTime;     // value in ms;
      var workTotalCost = report.Root.Children[0].Children[0].InnerTotalCost;

      // get assignments of the work which are the next siblings after the work (Type is ProjectReportItemType.AssignedWork and has UserId defined)
      var assignedUserId1 = report.Root.Children[0].Children[1].UserId;     // e.g. worker1UserId
      var assignmentWorkId1 = report.Root.Children[0].Children[1].TaskId;   // this is the same as workId
      var assignmentTotalTime1 = report.Root.Children[0].Children[1].TotalTime;     // value in ms;
      var assignmentTotalCost1 = report.Root.Children[0].Children[1].InnerTotalCost;

      var assignedUserId2 = report.Root.Children[0].Children[2].UserId;     // e.g. worker2UserId
      var assignmentWorkId2 = report.Root.Children[0].Children[2].TaskId;   // this is the same as workId
      var assignmentTotalTime2 = report.Root.Children[0].Children[2].TotalTime;     // value in ms;
      var assignmentTotalCost2 = report.Root.Children[0].Children[2].InnerTotalCost;

      SickLeave[] sickLeaves;
      using (API api = new API())
      {
        api.GetSickLeavesForCompany(AuthCode, out sickLeaves);
      }

      // find the sick leave you want and process it
      var sickleave = sickLeaves.First();
      var dailyDurationInMins = sickleave.DailyDurationInMins; //e.g. 8 * 60
      var userId = sickleave.UserId;  // UserId of a worker
      var startDate = sickleave.StartDate;    // new DateTime(2014, 1, 2)
      var endDate = sickleave.EndDate;    // new DateTime(2014, 1, 3)
      var numberOfWorkDays = sickleave.NumberOfWorkDays;    // 2 days

      using (API api = new API())
      {
        api.GetSickLeavesOfUser(AuthCode, Worker1UserId, out sickLeaves);
      }

      // find the sick leave you want and process it
      var sickleave = sickLeaves.First();
      var dailyDurationInMins = sickleave.DailyDurationInMins; //e.g. 8 * 60
      var userId = sickleave.UserId;  // UserId of a worker
      var startDate = sickleave.StartDate;    // new DateTime(2014, 1, 2)
      var endDate = sickleave.EndDate;    // new DateTime(2014, 1, 3)
      var numberOfWorkDays = sickleave.NumberOfWorkDays;    // 2 days

      //taskid null
      DictionaryAutoRule[] dictionaryAutoRules1;
      using (API api = new API())
      {
          var result = api.GetStartWorkDictionaryAutoRules(AuthCode, null, out dictionaryAutoRules1);
      }
    
      //taskid not null
      DictionaryAutoRule[] dictionaryAutoRules2;
      using (API api = new API())
      {
          var result = api.GetStartWorkDictionaryAutoRules(AuthCode, taskId, out dictionaryAutoRules2);
      }

      DictionaryAutoRule[] dictionaryAutoRules;
      using (API api = new API())
      {
          var result = api.GetStopWorkDictionaryAutoRules(AuthCode, out dictionaryAutoRules);
      }

      using (var api = new API())
      {
          Task_v4 task;
          var ret = api.GetTask_V3(AuthCode, taskId, false, out task);

          if (ret != GetTaskRet.OK)
          {
              Console.WriteLine("Error getting task data, error code: {0}", ret);
          }
          else
          {
              Console.WriteLine("Task id: {0}, name: {1}, description: {2}, category id: {3}", task.Id, task.Name, task.Description, task.CategoryId);
          }
      }      

      using (var api = new API.API())
      {
          TaskCategoryData[] taskCategories;
          var ret = api.GetTaskCategories(AuthCode, out taskCategories);

          if (ret != GetTaskCategoriesRet.OK)
          {
              Console.WriteLine("Error getting task categories for company, error code is: {0}", ret);
          }
          else
          {
              foreach (var tc in taskCategories)
              {
                  Console.WriteLine("Category id: {0}, category name: {1}", tc.Id, tc.Name);
              }
          }
      }

      // Get Hierarchy and check whether properties are filled
      TaskHierarchy_v2 hierarchy;
      using (API api = new API())
      {
        api.GetTaskHierarchy(AuthCode, true, out hierarchy);
      }

      // then get the root task
      APIWS.Task_v2 rootTask = hierarchy.Root;

      // or get children tasks
      var projectsUnderRoot = rootTask.Children;

      // or simply flatten the complete hierarchy
      var tasks = rootTask.Flatten(e => e.Children);



      // Misc methods for for flattening
      public interface IFlattenable
      {
      }

      public partial class Task_v2 : IFlattenable
      {
      }

      public static IEnumerable<T> Flatten<T> (this T source, Func<T, IEnumerable<T>> selector) where T : IFlattenable
      {
        yield return source;

        var childSeq = selector(source);
        if (childSeq != null)
        {
          foreach (T item in Flatten(childSeq, selector))
          {
            yield return item;
          } 
        }
      }

      public static IEnumerable<T> Flatten<T> (this IEnumerable<T> source, Func<T, IEnumerable<T>> selector)
      {
          foreach (T item in source)
          {
              yield return item;

              var childSeq = selector(item);
              if (childSeq != null)
              {
                  // recursive call to Traverse to get child of child ...
                  foreach (T itemRecurse in Flatten(childSeq, selector))
                  {
                      yield return itemRecurse;
                  }
              }
          }
      }
    

      using (var api = new API())
      {
          Task_v4[] tasks;
          var ret = api.GetTasksOfUser_v4(AuthCode, Worker1UserId, false, out tasks);

          if (ret != GetTasksOfUserRet.OK)
          {
              Console.WriteLine("Error getting tasks assigned to user, error code: {0}", ret);
          }
          else
          {
              foreach (var task in tasks)
              {
                  Console.WriteLine("Task id: {0}, task name: {1}, task category id: {2}, task description: {3}", task.Id, task.Name, task.CategoryId, task.Description);
              }
          }
      }

      using (var api = new API())
      {
      Worker_v2 worker;
      var ret = api.GetUser(AuthCode, 123, out worker);
      if (ret != GetUserRet.OK)
        Console.WriteLine("Error getting User")
      }

      using (var api = new API())
      {
      var groupId = 123;
      var authCode = Guid.NewGuid();

      WorkerGroup_v2 userGroup;
      var ret = api.GetUserGroup(authCode, groupId, out userGroup);
      if (ret != GetUserGroupRet.OK)
        Console.WriteLine("Error getting Group");
      }

      UserDictionaryAutoRules[] usersDictionaryAutoRules;
      using (API api = new API())
      {
          var result = api.GetUsersDictionaryAutoRules(AuthCode, new int[] { userId }, out usersDictionaryAutoRules);
      }

      using (var api = new API())
      {
          var startDate = new DateTime(2018, 1, 1);
          var endDate = new DateTime(2018, 1, 5);
          WorkFlowReport workflowReport;

          var ret = api.GetWorkflowReport(AuthCode, startDate, endDate, null, null, null, out workflowReport);

          if (ret != GetWorkflowReportRet.OK)
          {
              Console.WriteLine("Error getting workflow report, error code: {0}", ret);
          }
          else
          {
              foreach (var item in workflowReport.WorkFlowView)
              {
                  Console.WriteLine("User id: {0}, User last name: {1}, User first name: {2}, Item start date {3}, Item end date: {4}, Task name: {5}", 
                      item.UserId, item.LastName, item.FirstName, item.StartDate, item.EndDate, item.TaskName);
              }
          }
      }

      using (var api = new API())
      {
          var startDate = new DateTime(2018, 1, 1);
          var endDate = new DateTime(2018, 1, 5);
          WorktimeReport worktimeReport;

          var ret = api.GetWorktimeReport(AuthCode, startDate, endDate, null, null, out worktimeReport);

          if (ret != GetWorktimeReportRet.OK)
          {
              Console.WriteLine("Error getting worktime report, error code: {0}", ret);
          }
          else
          {
              foreach (var item in worktimeReport.WorktimeReportDataList)
              {
                  Console.WriteLine("User id: {0}, Active computer time in ms: {1}, Ad hoc meeting time in ms {2}, Idle time in ms: {3}", 
                      item.UserId, item.ActiveComputerWorkTimeMs, item.AdhocMeetingTimeMs, item.IdleComputerWorkTimeMs);
              }
          }
      }

      WorktimeSchedule[] resultSchedules;
      var rangeStart = DateTime.UtcNow;
      var rangeEnd = DateTime.UtcNow.AddDays(1);
      using (API api = new API())
      {
      var ret = api.GetWorktimeSchedulesOfUsers(AuthCode, null, rangeStart, rangeEnd, out resultSchedules);

      if (ret != GetWorktimeSchedulesOfUsersRet.OK)
      Console.WriteLine("Error getting WorktimeSchedules of users")
      }

      WorktimeSchedule_v2[] resultSchedules;
      var rangeStart = DateTime.UtcNow;
      var rangeEnd = DateTime.UtcNow.AddDays(1);
      using (API api = new API())
      {
      var ret = api.GetWorktimeSchedulesOfUsers_v2(AuthCode, null, rangeStart, rangeEnd, out resultSchedules);

      if (ret != GetWorktimeSchedulesOfUsersRet_v2.OK)
      Console.WriteLine("Error getting WorktimeSchedules of users")
      }

      using (var api = new API())
      {
          var authCode = Guid.NewGuid();

          var errors = new List<ImportError>
          var excel = "UEsDBBQABgAIAAAAIQBE/mk9fQEAAPgFAAATAAgCW0NvbnRlbnRfVHlwZXNdLnhtbCCiBAIooAACAA..."
          var ret = api.ImportLeavesAndSchedulesFromExcel(authCode, excel, UserIdentifierType.ExtId, true, false, out errors);

          if (ret != ImportLeavesAndSchedulesFromExcelRet.OK)
            Console.WriteLine("Error importing leaves and schedules");

          foreach(var error in errors)
            Console.WriteLine(String.Format("Message: {0} IsWarning: {1}", error.Message, error IsWarning));
      }

using (var api = new API())
{
            var projectId = 123;
            var authCode = Guid.NewGuid();
            
            Task_v4 subTreeRoot;
            api.ExportTaskSubTree(authCode, projectId, out subTreeRoot);
            
            // add a new project + task + assignment
            var newProject = new Task_v4
            {
                Id = 0,
                Type = TaskType.Project,
                Status = TaskStatus.Active,
                Name = "NewProject1",
                ParentId = subTreeRoot.Id,
                ExtId = "MyProjectExtId",
                TargetCost = 500,
                TargetStartDate = new DateTime(2022, 6, 1),
                TargetEndDate = new DateTime(2022, 7, 1),
                TargetPlannedWorkTimeInMinutes = 500,
            };

            var newTask = new Task_v4
            {
                Id = 0,
                Type = TaskType.Work,
                Status = TaskStatus.Active,
                Name = "NewTask",
                ParentId = 0,
                ExtId = "MyTaskExtId",
                TargetCost = 500,
                TargetStartDate = new DateTime(2022, 6, 1),
                TargetEndDate = new DateTime(2022, 7, 1),
                TargetPlannedWorkTimeInMinutes = 500,
                Description = "Descr",
            };

            var newAssignment = new TaskAssignment_v4
            {
                UserId = user2Id,
                StartDate = new DateTime(2022, 6, 1),
                EndDate = new DateTime(2022, 7, 1),
                Status = TaskStatus.Active,
                PlannedWorkTimeInMinutes = 500,
            };

            var newChildTree = subTreeRoot.Children.ToList();
            newChildTree.Add(newProject);
            subTreeRoot.Children = newChildTree.ToArray();
            newProject.Children = new[] { newTask };
            newTask.AssignedTo = new[] { newAssignment };

            // do the import
            var importRet = api.ImportTaskSubTree(_authCode, subTreeRoot);

            // process the errors
            if (importRet.GeneralErrorCode == ImportTaskSubTreeErrorCode.ErrorWithDetails)
            {
               foreach (var error in importRet.Errors)
                    Console.WriteLine(String.Format("TaskId: {0} | UserId: {1} | ErrorMessage: {2}", error.TaskId, error.UserId, error.ErrorMessage));
            }
}

var organizationHierarchy = new OrganizationHierarchy_v2();

var root = new RootWorkerGroup_v2();

// get groups and workers from external system and build up the organization hierarchy
var group1 = new WorkerGroup_v2 { ExtId = "1AA", Name = "Group1" };
var group2 = new WorkerGroup_v2 { ExtId = "2AA", Name = "Group2" };
var group3 = new WorkerGroup_v2 { ExtId = "3AA", Name = "Group3" };
var group4 = new WorkerGroup_v2 { ExtId = "104AA", Name = "Group4" };
var worker1 = new Worker_v2 { ExtId = "4AA", LastName = "Worker1", Email = "worker1@example.com", FirstName = "FirstName"};
var worker2 = new Worker_v2 { ExtId = "5AA", LastName = "Worker2", Email = "worker2@example.com", FirstName = "FirstName" };
var worker3 = new Worker_v2 { ExtId = "6AA", LastName = "Worker3", Email = "worker3@example.com", FirstName = "FirstName" };
var worker4 = new Worker_v2 { ExtId = "7AA", LastName = "Worker4", Email = "worker4@example.com", FirstName = "FirstName" };
var worker5 = new Worker_v2 { ExtId = "8AA", LastName = "Worker5", Email = "worker5@example.com", FirstName = "FirstName" };
var worker6 = new Worker_v2 { ExtId = "9AA", LastName = "Worker6", Email = "worker6@example.com", FirstName = "FirstName" };

group1.Children = new OrganizationHierarchyItem_v2[] { worker1, worker2 };
group2.Children = new OrganizationHierarchyItem_v2[] { worker3, worker4 };
group3.Children = new OrganizationHierarchyItem_v2[] { worker5, worker6 };
group4.Children = new OrganizationHierarchyItem_v2[] { };

root.Children = new OrganizationHierarchyItem_v2[] { group1, group2, group3, group4 };

organizationHierarchy.Root = root;

// Hierarchy is built, import it into JC360 (using JC360 webservice)
Guid AuthCode = Guid.Parse("YourCompanyAuthCodeHere");
using (API api = new API())
{
api.ImportUsersAndGroups(AuthCode, organizationHierarchy, true, true);
}

      using (var api = new API())
      {
        var authCode = Guid.NewGuid();
        var targetUserId = 123456;
        var startDateInUtc = DateTime.UtcNow.AddMonths(-1);
        var endDateInUtc = DateTime.UtcNow;
        var taskId = 123456;
        var comment = "comment";
        
        //Adds worktime as manualworkitems, which you can undo by deleting by the Id of the created ManualWorkItem
        var ret = api.ModifyWorktime(authCode, targetUserId, startDateInUtc, endDateInUtc, ModifyWorktimeMethod.Add, taskId, comment);

        if (ret != ModifyWorktimeRet.OK)
          Console.WriteLine("Error adding manualworkitem for the user for the given period");
        
        //Overwrites the taskId of any worktime in the given period with the given taskId
        var ret = api.ModifyWorktime(authCode, targetUserId, startDateInUtc, endDateInUtc, ModifyWorktimeMethod.Replace, taskId, comment);

        if (ret != ModifyWorktimeRet.OK)
          Console.WriteLine("Error overwriting existing worktime of the user with the given taskid for the given period");
          
        //Deletes any worktime and any collected data in the given period with the given taskId
        var ret = api.ModifyWorktime(authCode, targetUserId, startDateInUtc, endDateInUtc, ModifyWorktimeMethod.Delete, null, comment);

        if (ret != ModifyWorktimeRet.OK)
          Console.WriteLine("Error deleting existing worktime of the user for the given period");
      }

      using (var api = new API())
      {
          var ret = api.MoveTask_v3(AuthCode, taskId, targetProjectId);

          if (ret != MoveTaskRet_v3.OK)                
              Console.WriteLine("Error moving task: {0} to project {1, error code: {2}}", taskId, targetProjectId, ret);                
      }

      using (var api = new API())
      {
        var ret = api.MoveUser(AuthCode, 123, 234);
        if (ret != MoveUserRet.OK)
          Console.WriteLine("Error moving User");
      }

      using (var api = new API())
      {
        var ret = api.MoveUserGroup(AuthCode, 123, 234);
        if (ret != MoveUserGroupRet.OK)
          Console.WriteLine("Error moving Group");
      }

      var holidayLimit1Id = 123;
      using (API api = new API())
      {
        api.RemoveHolidayLimitsForUser(AuthCode, holidayLimit1Id);
      }

      using (var api = new API())
      {
          var ret = api.ReopenTask(AuthCode, taskId);

          if (ret != ReopenTaskRet.OK)
          {
              Console.WriteLine("Error reopening project/task: {0}, error code: {1}", taskId, ret);
          }
      }

      using (var api = new API())
      {
        var userId = 123;
        var authCode = Guid.NewGuid();

        var ret = api.ReopenUser(authCode, userId);
        if (ret != ReopenUserRet.OK)
          Console.WriteLine("Error reopening User");
      }

      var Work1Id = 120221;
      var extId = "358111";

      using (var api = new API())
      {
          var ret = api.SetExternalIdForTask(AuthCode, Work1Id, extId);

          if (ret != SetExternalIdForTaskRet.OK)
          {
              Console.WriteLine("Error setting ExtId for task: {0}, error code: {1}", Work1Id, ret);
          }
      }

      // Set/Change HourlyWages for users
      var wages = new HourlyWage[]
      {
        new HourlyWage { StartDate = new DateTime(2010, 1, 1), Amount = 3000 },
        new HourlyWage { StartDate = new DateTime(2011, 1, 1), Amount = 4000 },
        new HourlyWage { StartDate = new DateTime(2011, 6, 1), Amount = 5000 }
      };

      // set hourly wages
      using (API api = new API())
      {
        api.SetHourlyWagesForUser(AuthCode, worker1UserID, wages);
      }
      
      // Add/Change/Remove hourly wages
      wages = new HourlyWage[]
      {
          new HourlyWage { StartDate = new DateTime(2010, 1, 1), Amount = 3100 },    // change
          new HourlyWage { StartDate = new DateTime(2010, 6, 1), Amount = 3500 },    // add
          new HourlyWage { StartDate = new DateTime(2011, 1, 1), Amount = 4000 },    // leave
          new HourlyWage { StartDate = new DateTime(2013, 1, 1), Amount = 7000 },    // add
      };

      using (API api = new API())
      {
          api.SetHourlyWagesForUser(AuthCode, worker1UserID, wages);
      }
      
      // Remove every hourly wage
      using (API api = new API())
      {
          api.SetHourlyWagesForUser(AuthCode, worker1UserID, new HourlyWage[0]);
      }

      using (var api = new API())
      {
          var phoneNumber = "+36201234567";
          var ret = api.SetPhoneNumberForUser(AuthCode, Worker1UserId, phoneNumber);

          if (ret != SetPhoneNumberForUserRet.OK)
              Console.WriteLine("Error setting phone number ({0}) for user: {1}, error: {2}", phoneNumber, Worker1UserId, ret);
      }

      using (var api = new API())
      {                                
          var costCenters = api.GetCostCenters_v2(AuthCode);
          var costCenterData = costCenters.FirstOrDefault();

          if (costCenterData == null) return;

          costCenterData.Description = "Modified description";
          var ret = api.UpdateCostCenter_v2(AuthCode, costCenterData);

          if (ret != CostCenterUpdateError.OK)
              Console.WriteLine("Error updating cost center data, error code: {0}", ret);
      }

      using (var api = new API())
      {
          var targetProjectId = 120221;
          Task_v4 project;
          var ret = api.GetTask_V3(AuthCode, targetProjectId, false, out project);

          if (ret != GetTaskRet.OK)
          {
              Console.WriteLine("Error getting task data, error code: {0}", ret);
          }
          else
          {
              project.Name += " added name";
              var ret2 = api.UpdateProject_v3(AuthCode, targetProjectId, project.Name, project.Description, project.TargetPlannedWorkTimeInMinutes,
                project.TargetStartDate, project.TargetEndDate, project.TargetCost, project.TaxId, project.TaskPriority, false, null);

              if (ret2 != UpdateProjectRet_v3.OK)
                  Console.WriteLine("Error updating project {0}, error code: {1}", targetProjectId, ret);
          }                
      }

      using (var api = new API())
      {
          var targetProjectId = 120221;
          var ret = api.UpdateProjectMembership(AuthCode, targetProjectId, Worker1UserId, true);

          if (ret != UpdateProjectMembershipRet.OK)
              Console.WriteLine("Error updating project membership in project {0}, for user: {1}, error code: {2}", targetProjectId, Worker1UserId, ret);
      }

      var systemSetting = new SystemSetting
      {
          UserId = Worker1UserId,
          CoreTime = new CoreTimeSetting
          {
              StartTime = null,
              EndTime = null,
              MinimumWorkTime = null,
              StartOffset = null,
              EndOffset = null
          },
          Client = new ClientSetting
          {
              WorktimeStartInMins = null,
              WorktimeEndInMins = null,
              AfterWorktimeIdleInMins = null,
              DuringWorkTimeIdleInMins = null,
              DuringWorkTimeIdleManualIntervalInMilisec = null,
              MaxManualMeetingIntervalInMilisec = null,
              RuleRestrictions = null,
              ScreenshotQuality = null,
              BusyTimeThreshold = null,
              MaxOfflineWorkItems = null,
              CoincidentalClientsEnabled = null,
              DefaultTaskId = null,
              IsOutlookAddinMailTrackingUseSubject = null
          },
          Meeting = new MeetingSetting
          {
              EnableMeetingTracking = null,
              EnableLotusNotesMeetingTracking = null,
              DefaultTaskId = null,
              IsMeetingSubjectMandatory = null,
              IsOfflineWorkingTimeRequestAutomatic = null,
              SynchronizeCalendarMeetingModifications = null,
              AllowApprovalOfMeetingsLongerOrEqualThan24Hours = null,
              KeepMeetingParallelWorktime = null,
              AreTentativeMeetingsSynched = null
          },
          Mobile = new MobileSetting
          {
              LocationTrackMode = null,
              PrivateCallDuration = null,
              AfterWorkTimeIdleMinutes = null,
              WorkCallDuration = null
          },
          IncidentManager = new IncidentManagerSetting(), // Obsolete, so not explained
          Other = new OtherSetting
          {
              CostCenterId = null,
              TimeZoneId = null,
              CalendarId = null,
              DailyWorkTimeInMinutes = 480,
              TaskMandatoryFields = null,
              TaskAssignmentMandatoryFields = null,
              ManualWorkItemEditAgeLimit = null,
              MinNumOfActiveUsersInGroup = null,
              MinPercentOfActiveUsersInGroup = null
          }
      };

      using (var api = new API())
      {
          api.Timeout = Int32.MaxValue;

          var ret = api.UpdateSystemSettingForUser(AuthCode, systemSetting);

          if (ret != UpdateSystemSettingForUserRet.OK)
              Console.WriteLine("Error updating system setting for user {0}, error code: {1}", Worker1UserId, ret);
      }      

      using (var api = new API())
      {
          var ret = api.UpdateTaskAssignment_v3(AuthCode, Worker1UserId, taskId, null, null, 200);

          if (ret != UpdateTaskAssignmentRet_v3.OK)
              Console.WriteLine("Error updating task ({0}), error code: {1}", taskId, ret);
      }      

      using (var api = new API())
      {
        var ret = api.UpdateUser_v2(AuthCode, 123, "firstname", "lastname", "test@test.com", UserAccessLevel.Administrator, 1, "en-US", null, null, null, null, null);
        if (ret != UpdateUserRet.OK)
          Console.WriteLine("Error updating User")
      }

      using (var api = new API())
      {
        var groupId = 123;
        var authCode = Guid.NewGuid();

        var ret = api.UpdateUserGroup(authCode, groupId, "GroupName");
        if (ret != UpdateUserGroupRet.OK)
          Console.WriteLine("Error updating Group");
      }

      using (var api = new API())
      {
          var ret = api.UpdateWork_v4(AuthCode, taskId, "Updated name", null, null, null, null, null, null, null, null, null, null, true, null, null);

          if (ret != UpdateWorkRet_v4.OK)
              Console.WriteLine("Error updating task ({0}), error code = {1}", taskId, ret);
      }      

      var scheduleId = 123;
      var targetUserId = 123;

      var schedule = new WorktimeSchedule
      {
      Id = scheduleId,
      LocalDay = new DateTime(2018, 10, 19),
      UserId = targetUserId,
      IsInOffice = false
      };

      var items = new List<WorktimeScheduleItem>()
      {
      new WorktimeScheduleItem
      {
      UtcStartDate = DateTime.UtcNow.LocalDay.AddHours(6),
      UtcEndDate = DateTime.UtcNow.LocalDay.AddHours(8),
      TaskId = 1234,
      IsOvertime = false,
      }
      };

      schedule.Items = items.ToArray();

      using (API api = new API())
      {
      var ret = api.UpdateWorktimeSchedule(AuthCode, schedule);
      if (ret != UpdateWorktimeScheduleRet.OK)
      Console.WriteLine("Error updating WorktimeSchedule")
      }

      var scheduleId = 123;
      var targetUserId = 123;

      var schedule = new WorktimeSchedule_v2
      {
      Id = scheduleId,
      LocalDay = new DateTime(2018, 10, 19),
      UserId = targetUserId,
      IsInOffice = false,
      IsWorkDay = true
      };

      var items = new List<WorktimeScheduleItem_v2>()
      {
      new WorktimeScheduleItem_v2
      {
      UtcStartDate = DateTime.UtcNow.LocalDay.AddHours(6),
      UtcEndDate = DateTime.UtcNow.LocalDay.AddHours(8),
      TaskId = 1234,
      IsOvertime = false,
      CategoryId = 5678
      }
      };

      schedule.Items = items.ToArray();

      using (API api = new API())
      {
      var ret = api.UpdateWorktimeSchedule_v2(AuthCode, schedule);
      if (ret != UpdateWorktimeScheduleRet_v2.OK)
      Console.WriteLine("Error updating WorktimeSchedule")
      }

      var fileName = "MyExcelFile";
      var uploadedWorkbook = CreateSampleWorkbook();
      var fileContent = uploadedWorkbook.SaveToStream().ToArray();
      int dataSourceId;

      using (API api = new API())
      {
        api.UploadDataSourceFile(AuthCode, fileName, fileContent, out dataSourceId);
      }

      //Create simple startwork dictionaryautorule start
      
      DictionaryAutoRuleSample[] dictionaryAutoRuleSamples;
      using (API api = new API())
      {
          var result = api.GetCompanyDictionaryAutoRuleSamples(AuthCode, out dictionaryAutoRuleSamples);
          Assert.AreEqual(result, GetCompanyDictionaryAutoRuleSamplesRet.OK);
      }

      var samples = dictionaryAutoRuleSamples
          .Where(item => item.Type == DictionaryAutoRuleSampleType.StartWork && !item.IsComplex)
          .ToList();

      var assignment = new StartWorkDictionaryAutoRuleAssignment()
      {
          TaskId = taskId
      };

      var content = new SimpleDictionaryAutoRuleContent()
      {
          Parameters = new DictionaryAutoRuleParameter[]
          {
              new DictionaryAutoRuleParameter()
              {
                  SampleId = samples[0].Id,
                  ParameterId = samples[0].Parameters[0].Id
              }
          },
          KeywordDetails = new DictionaryAutoRuleKeywordDetails[]
          {
              new DictionaryAutoRuleKeywordDetails()
              {
                  Keyword = "apitest1",
                  IsStartFixed = false,
                  IsEndFixed = false,
                  IsRegex = false
              }
          }
      };

      var dictionaryAutoRule = new DictionaryAutoRule()
      {
          Assignment = assignment,
          Content = content
      };

      DictionaryAutoRule createdDictionaryAutoRule;
      using (API api = new API())
      {
          var result = api.UpsertStartWorkDictionaryAutoRule(AuthCode, dictionaryAutoRule, out createdDictionaryAutoRule);
      }
      
      //Create simple startwork dictionaryautorule end
      
      //Create complex startwork dictionaryautorule start
      
      DictionaryAutoRuleSample[] dictionaryAutoRuleSamples;
      using (API api = new API())
      {
          var result = api.GetCompanyDictionaryAutoRuleSamples(AuthCode, out dictionaryAutoRuleSamples);
      }

      var samples = dictionaryAutoRuleSamples
          .Where(item => item.Type == DictionaryAutoRuleSampleType.StartWork && item.IsComplex)
          .ToList();

      var assignment = new StartWorkDictionaryAutoRuleAssignment()
      {
          TaskId = taskId
      };

      var content = new ComplexDictionaryAutoRuleContent()
      {
          ParameterContent = new DictionaryAutoRuleParameterContent[]
          {
              new DictionaryAutoRuleParameterContent()
              {
                  KeywordDetails = new DictionaryAutoRuleKeywordDetails[]
                  {
                      new DictionaryAutoRuleKeywordDetails()
                      {
                          Keyword = "apitest1",
                          IsStartFixed = false,
                          IsEndFixed = false,
                          IsRegex = false
                      }
                  },
                  ParameterId = samples[0].Parameters[0].Id,
                  SampleId = samples[0].Id
              },
              new DictionaryAutoRuleParameterContent()
              {
                  KeywordDetails = new DictionaryAutoRuleKeywordDetails[]
                  {
                      new DictionaryAutoRuleKeywordDetails()
                      {
                          Keyword = "apitest2",
                          IsStartFixed = false,
                          IsEndFixed = false,
                          IsRegex = false
                      }
                  },
                  ParameterId = samples[0].Parameters[1].Id,
                  SampleId = samples[0].Id
              }
          }
      };

      var dictionaryAutoRule = new DictionaryAutoRule()
      {
          Assignment = assignment,
          Content = content
      };

      DictionaryAutoRule createdDictionaryAutoRule;
      using (API api = new API())
      {
          var result = api.UpsertStartWorkDictionaryAutoRule(AuthCode, dictionaryAutoRule, out createdDictionaryAutoRule);
      }
  
      //Create complex startwork dictionaryautorule end

      //Create simple stopwork dictionaryautorule start
      DictionaryAutoRuleSample[] dictionaryAutoRuleSamples;
      using (API api = new API())
      {
          var result = api.GetCompanyDictionaryAutoRuleSamples(AuthCode, out dictionaryAutoRuleSamples);
      }

      var samples = dictionaryAutoRuleSamples
          .Where(item => item.Type == DictionaryAutoRuleSampleType.StopWork && !item.IsComplex)
          .ToList();

      var assignment = new StopWorkDictionaryAutoRuleAssignment()
      {
          UserIds = new int[] { RegistratorUserId },
          RoleIds = new int[] { workerGroupRole.Id }
      };

      var content = new SimpleDictionaryAutoRuleContent()
      {
          Parameters = new DictionaryAutoRuleParameter[]
          {
              new DictionaryAutoRuleParameter()
              {
                  SampleId = samples[0].Id,
                  ParameterId = samples[0].Parameters[0].Id
              }
          },
          KeywordDetails = new DictionaryAutoRuleKeywordDetails[]
          {
              new DictionaryAutoRuleKeywordDetails()
              {
                  Keyword = "apitest1",
                  IsStartFixed = false,
                  IsEndFixed = false,
                  IsRegex = false
              }
          }
      };

      var dictionaryAutoRule = new UnitTests.APIWS.DictionaryAutoRule()
      {
          Assignment = assignment,
          Content = content
      };

      DictionaryAutoRule createdDictionaryAutoRule;
      using (API api = new API())
      {
          var result = api.UpsertStopWorkDictionaryAutoRule(AuthCode, dictionaryAutoRule, out createdDictionaryAutoRule);
      }
      //Create simple stopwork dictionaryautorule end
      
      //Create complex stopwork dictionaryautorule start
      DictionaryAutoRuleSample[] dictionaryAutoRuleSamples;
      using (API api = new API())
      {
          var result = api.GetCompanyDictionaryAutoRuleSamples(AuthCode, out dictionaryAutoRuleSamples);
      }

      var samples = dictionaryAutoRuleSamples
          .Where(item => item.Type == DictionaryAutoRuleSampleType.StopWork && item.IsComplex)
          .ToList();

      var assignment = new StopWorkDictionaryAutoRuleAssignment()
      {
          UserIds = new int[] { RegistratorUserId },
          RoleIds = new int[] { workerGroupRole.Id }
      };

      var content = new ComplexDictionaryAutoRuleContent()
      {
          ParameterContent = new DictionaryAutoRuleParameterContent[]
          {
              new DictionaryAutoRuleParameterContent()
              {
                  KeywordDetails = new DictionaryAutoRuleKeywordDetails[]
                  {
                      new DictionaryAutoRuleKeywordDetails()
                      {
                          Keyword = "apitest1",
                          IsStartFixed = false,
                          IsEndFixed = false,
                          IsRegex = false
                      }
                  },
                  ParameterId = samples[0].Parameters[0].Id,
                  SampleId = samples[0].Id
              },
              new DictionaryAutoRuleParameterContent()
              {
                  KeywordDetails = new DictionaryAutoRuleKeywordDetails[]
                  {
                      new DictionaryAutoRuleKeywordDetails()
                      {
                          Keyword = "apitest2",
                          IsStartFixed = false,
                          IsEndFixed = false,
                          IsRegex = false
                      }
                  },
                  ParameterId = samples[0].Parameters[1].Id,
                  SampleId = samples[0].Id
              }
          }
      };

      var dictionaryAutoRule = new UnitTests.APIWS.DictionaryAutoRule()
      {
          Assignment = assignment,
          Content = content
      };

      DictionaryAutoRule createdDictionaryAutoRule;
      using (API api = new API())
      {
          var result = api.UpsertStopWorkDictionaryAutoRule(AuthCode, dictionaryAutoRule, out createdDictionaryAutoRule);
      }
      //Create complex stopwork dictionaryautorule end