private static ProjectClient CreateProjectClient()
{
var http = CreateHttpClientWrapper();
var projectClient = new ProjectClient(http);
return(projectClient);
}
async void setTask(ProjectClient project, ProjectTaskClient projTask)
{
leProjTask.ItemsSource = project.Tasks ?? await project.LoadTasks(api);
leProjTask.SelectedItem = projTask;
leProjTask.Focus();
}
public async Task <ActionResult> Delete(int id)
{
new ProjectClient();
var project = await ProjectClient.GetProjectAsync(id);
return(View(project));
}
void InitPage(CrudAPI crudapi)
{
StartLoadCache();
dAddress.Header = Localization.lookup("DeliveryAddr");
layoutControl = layoutItems;
cbCountry.ItemsSource = Enum.GetValues(typeof(Uniconta.Common.CountryCode));
lePersonInCharge.api = lePurchaser.api = lePrStandard.api = leAccount.api = lePayment.api = leVat.api = cmbDim1.api = cmbDim2.api = cmbDim3.api = cmbDim4.api = cmbDim5.api = leGroup.api = leMasterProject.api = lePrType.api = leInstallation.api = crudapi;
Utility.SetDimensions(crudapi, lbldim1, lbldim2, lbldim3, lbldim4, lbldim5, cmbDim1, cmbDim2, cmbDim3, cmbDim4, cmbDim5, usedim);
if (LoadedRow == null)
{
frmRibbon.DisableButtons("Delete");
if (!isCopiedRow)
{
editrow = CreateNew() as ProjectClient;
if (Debtor != null)
{
editrow.SetMaster(Debtor);
leAccount.IsEnabled = false;
}
else
{
editrow.SetMaster(crudapi.CompanyEntity);
}
}
}
layoutItems.DataContext = editrow;
frmRibbon.OnItemClicked += frmRibbon_OnItemClicked;
editrow.PropertyChanged += Editrow_PropertyChanged;
}
public async Task <ActionResult> Index()
{
new ProjectClient();
var projects = await ProjectClient.GetProjectsAsync();
return(View(projects));
}
public async Task CreateEntityDefinitionTest()
{
var storage = new InMemoryStorage();
var client = new ProjectClient(storage);
Guid entityDefinitionId = Guid.NewGuid();
var entityDefinitionRequest = new CreateEntityDefinitionRequest()
{
Id = entityDefinitionId,
Name = "Entity",
Fields = new FieldDefinition[] {},
};
var entityDefinition = await client.CreateEntityDefinitionAsync(entityDefinitionRequest);
Assert.NotNull(entityDefinition);
Assert.Equal(entityDefinitionId, entityDefinition.Id);
var retreived = await client.GetEntityDefinitionAsync(entityDefinitionId);
Assert.NotNull(retreived);
Assert.Equal(entityDefinitionRequest.Name, retreived.Name);
}
public ProjectDashboard(Project currentProject)
{
InitializeComponent();
CurrentPage = this.Title;
DataContext = this;
_projectClient = new ProjectClient();
_userClient = new UserClient();
Permissions = new Permissions((User)Application.Current.Properties["user"], currentProject);
CurrentProject = currentProject;
_projects = _userClient.GetProjectsForUser(((User)Application.Current.Properties["user"]).Id);
ProjectDropDownButton.Content = currentProject.Name;
AddProjectsToDropdownList();
try
{
TeamMembers = new ObservableCollection <User>(_projectClient.GetProjectTeam(currentProject.Id));
}
catch (RestResponseErrorException ex)
{
MessageBoxUtil.ShowErrorBox(ex.Message);
}
}
public void Start()
{
Console.WriteLine("Engine starting work...");
var Engine = EngineFacade.Instance;
var projectClient = new ProjectClient(System.Net.Dns.GetHostEntry("localhost").AddressList[0], 9090);
Engine.ProjectClient = projectClient;
Engine.XMLConverter.RegisterSerizalizer(new RegisterUserRequest().ID, new XmlSerializer(typeof(RegisterUserRequest), new Type[] { typeof(Request), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new AuthorizeUserRequest().ID, new XmlSerializer(typeof(AuthorizeUserRequest), new Type[] { typeof(Request), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new UpdateProjectRequest().ID, new XmlSerializer(typeof(UpdateProjectRequest), new Type[] { typeof(Request), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new DeleteProjectRequest().ID, new XmlSerializer(typeof(DeleteProjectRequest), new Type[] { typeof(Request), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new GetAllProjectsRequest().ID, new XmlSerializer(typeof(GetAllProjectsRequest), new Type[] { typeof(Request), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new UpdateTopicRequest().ID, new XmlSerializer(typeof(UpdateTopicRequest), new Type[] { typeof(Request), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new GetAllTopicsRequest().ID, new XmlSerializer(typeof(GetAllTopicsRequest), new Type[] { typeof(Request), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new GetAllParticipantsRequest().ID, new XmlSerializer(typeof(GetAllParticipantsRequest), new Type[] { typeof(Request), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new RegisterUserResponse().ID, new XmlSerializer(typeof(RegisterUserResponse), new Type[] { typeof(Response), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new AuthorizeUserResponse().ID, new XmlSerializer(typeof(AuthorizeUserResponse), new Type[] { typeof(Response), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new UpdateProjectResponse().ID, new XmlSerializer(typeof(UpdateProjectResponse), new Type[] { typeof(Response), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new DeleteProjectResponse().ID, new XmlSerializer(typeof(DeleteProjectResponse), new Type[] { typeof(Response), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new GetAllProjectsResponse().ID, new XmlSerializer(typeof(GetAllProjectsResponse), new Type[] { typeof(Response), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new UpdateTopicResponse().ID, new XmlSerializer(typeof(UpdateTopicResponse), new Type[] { typeof(Response), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new GetAllTopicsResponse().ID, new XmlSerializer(typeof(GetAllTopicsResponse), new Type[] { typeof(Response), typeof(BaseMessage) }));
Engine.XMLConverter.RegisterSerizalizer(new GetAllParticipantsResponse().ID, new XmlSerializer(typeof(GetAllParticipantsResponse), new Type[] { typeof(Response), typeof(BaseMessage) }));
BaseMessage.counter = 0;
}
public IActionResult Edit(int id, ProjectClient ProjectClient)
{
db.Entry(ProjectClient).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult Add(ProjectClient ProjectClient)
{
db.ProjectClient.Add(ProjectClient);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public UserDashboard()
{
InitializeComponent();
CurrentPage = this.Title;
DataContext = this;
user = ((User)Application.Current.Properties["user"]);
UserLabel = user.GetFullName();
string profileImageFileName;
if (user.ProfilePicture != null)
{
profileImageFileName = user.ProfilePicture;
}
else
{
profileImageFileName = Properties.Settings.Default.DefaultProfileImage;
}
string profileImagePath = Properties.Settings.Default.ProfileImageDirectory + profileImageFileName;
_projectClient = new ProjectClient();
_userClient = new UserClient();
InitialiseProjects();
}
public ProjectClient CreateProjectClient()
{
_projectClient = new ProjectClient(_binding, _endpointAddress);
SetCredenticalProperties <ProjectClient, Project>(_projectClient);
return(_projectClient);
}
private void GenerateSelectedInvoice(ProjectClient selectedItem)
{
var generateInvoiceDialog = new CWProjectGenerateInvoice(api, BasePage.GetSystemDefaultDate(), showToFromDate: true, showEmailList: true, showSendOnlyEmailCheck: true);
#if SILVERLIGHT
generateInvoiceDialog.Height = 360.0d;
#else
generateInvoiceDialog.DialogTableId = 2000000051;
#endif
generateInvoiceDialog.Closed += async delegate
{
if (generateInvoiceDialog.DialogResult == true)
{
busyIndicator.BusyContent = Uniconta.ClientTools.Localization.lookup("GeneratingPage");
busyIndicator.IsBusy = true;
#if !SILVERLIGHT
var invoicePostingResult = new UnicontaClient.Pages.InvoicePostingPrintGenerator(
#else
var invoicePostingResult = new InvoicePostingPrintGenerator(
#endif
api, this, selectedItem, null, generateInvoiceDialog.GenrateDate, generateInvoiceDialog.IsSimulation, CompanyLayoutType.Invoice, (generateInvoiceDialog.ShowInvoice || generateInvoiceDialog.InvoiceQuickPrint), generateInvoiceDialog.InvoiceQuickPrint,
generateInvoiceDialog.NumberOfPages, generateInvoiceDialog.SendByEmail, generateInvoiceDialog.EmailList, generateInvoiceDialog.SendOnlyEmail, generateInvoiceDialog.FromDate, generateInvoiceDialog.ToDate,
generateInvoiceDialog.InvoiceCategory, null);
var result = await invoicePostingResult.Execute();
busyIndicator.IsBusy = false;
if (result)
{
Task reloadTask = null;
if (!generateInvoiceDialog.IsSimulation)
{
reloadTask = Filter();
}
string msg = Uniconta.ClientTools.Localization.lookup("InvoiceProposal");
if (invoicePostingResult.PostingResult.Header._InvoiceNumber != 0)
{
msg = string.Format(Uniconta.ClientTools.Localization.lookup("InvoiceHasBeenGenerated"), Uniconta.ClientTools.Localization.lookup("Invoice"), invoicePostingResult.PostingResult.Header.InvoiceNum);
msg = string.Format("{0}{1}{2} {3}", msg, Environment.NewLine, Uniconta.ClientTools.Localization.lookup("LedgerVoucher"), invoicePostingResult.PostingResult.Header._Voucher);
#if !SILVERLIGHT
if (generateInvoiceDialog.GenerateOIOUBLClicked && api.CompanyEntity._OIOUBLSendOnServer == false)
{
DebtorOrders.GenerateOIOXml(api, invoicePostingResult.PostingResult);
}
#endif
}
UnicontaMessageBox.Show(msg, Uniconta.ClientTools.Localization.lookup("Message"), MessageBoxButton.OK);
}
else
{
Utility.ShowJournalError(invoicePostingResult.PostingResult.ledgerRes, dgProjectMultiLineGrid);
}
}
};
generateInvoiceDialog.Show();
}
public CWCreateOrderFromProject(CrudAPI crudApi, bool createOrder, ProjectClient project, ProjectTaskClient projTask = null) : this(crudApi, createOrder)
{
if (crudApi.CompanyEntity.ProjectTask && project != null)
{
setTask(project, projTask);
lblProjTask.Visibility = leProjTask.Visibility = Visibility.Visible;
}
}
public async Task GetProjectsInvalidJSON()
{
// arrange
var client = new ProjectClient(SetupClient("not json"));
// act
await client.GetUserProjectsAsync();
}
private GitLabClient(string hostUrl, string apiToken)
{
_api = new API(hostUrl, apiToken);
Users = new UserClient(_api);
Projects = new ProjectClient(_api);
Issues = new IssueClient(_api);
Groups = new NamespaceClient(_api);
}
public async System.Threading.Tasks.Task <ActionResult> Create(int projectId)
{
new ProjectClient();
var project = await ProjectClient.GetProjectAsync(projectId);
ViewBag.project = project;
return(View());
}
private static async Task TestPhaseChange(string startPhases, string changedPhases, string[] ignorePhases = null)
{
// Ensure the projects are there
await ProjectClient.EnsureTestProjects();
// DATA SET UP -------------------------------
// Reconfigure the categories
var categoriesBackup = await PortfolioConfigClient.UpdatePhasesAsync(TestSettings.TestPortfolio, startPhases);
Assert.AreEqual(PhaseBackup, categoriesBackup);
GetProjectQueryDTO options = await PortfolioConfigClient.GetFilterOptionsAsync(TestSettings.TestPortfolio);
var phaseOptions = options.Options.PhaseItems;
if (ignorePhases != null)
{
phaseOptions.RemoveAll(p => ignorePhases.Contains(p.Display));
}
List <ProjectUpdateModel> updates = new List <ProjectUpdateModel>();
Action <ProjectUpdateModel, string> ensurePhase = (p, ph) =>
{
if (p.phase != ph)
{
p.phase = ph;
updates.Add(p);
}
};
var testProjects = await ProjectClient.GetTestProjectsAsync();
int ci = 0;
for (int i = 0; i < ProjectClient.TestProjectCount; i++)
{
ensurePhase(testProjects[i], phaseOptions[ci++].Value);
if (ci >= phaseOptions.Count)
{
ci = 0;
}
}
await ProjectClient.UpdateProjectsAsync(updates);
updates.Clear();
// CHANGE CATEGORIES -------------------------------
categoriesBackup = await PortfolioConfigClient.UpdatePhasesAsync(TestSettings.TestPortfolio, changedPhases);
Assert.AreEqual(startPhases, categoriesBackup);
// Restore the categories
categoriesBackup = await PortfolioConfigClient.UpdatePhasesAsync(TestSettings.TestPortfolio, categoriesBackup);
Assert.AreEqual(changedPhases, categoriesBackup);
}
public RESTClientScenarios(string collectionUri, string project)
{
Connection = new VssConnection(new Uri(collectionUri), new VssClientCredentials());
WitClient = Connection.GetClient <WorkItemTrackingHttpClient>();
ProjectClient = Connection.GetClient <ProjectHttpClient>();
TeamProject = ProjectClient.GetProject(project).Result;
WorkItemsAdded = new HashSet <int>();
DefaultWorkItemTypeCategory = WitClient.GetWorkItemTypeCategoryAsync(TeamProject.Id, DefaultCategoryReferenceName).Result;
DefaultWorkItemType = DefaultWorkItemTypeCategory.DefaultWorkItemType;
}
public DexTranslateApiClient(HttpClient client, string baseUrl, string apiKey, string apiSecret)
{
_client = client;
_client.DefaultRequestHeaders.Add("ApiKey", apiKey);
_client.DefaultRequestHeaders.Add("ApiSecret", apiSecret);
_languageClient = new LanguageClient(_client, baseUrl);
_projectClient = new ProjectClient(_client, baseUrl);
_translationClient = new TranslationClient(_client, baseUrl);
}
public CreateProject()
{
InitializeComponent();
CurrentPage = this.Title;
DataContext = this;
_client = new ProjectClient();
_currentUser = (User)Application.Current.Properties["user"];
PageSetup();
}
internal TfsClient(ITfsClientExecutor executor)
{
Assert.NotNull(executor, "executor");
Executor = executor;
Project = new ProjectClient(Executor);
Git = new GitClient(Executor);
Team = new TeamClient(Executor);
TeamRoom = new TeamRoomClient(Executor);
}
public async Task GetProjectsThrows()
{
// arrange
var mockHttpClient = new MockHttpClient();
mockHttpClient.GetAsyncErr = new Exception("whoops");
var client = new ProjectClient(mockHttpClient);
// act
await client.GetUserProjectsAsync();
}
private void CreateOrder(ProjectClient selectedItem)
{
#if SILVERLIGHT
var cwCreateOrder = new CWCreateOrderFromProject(api);
#else
var cwCreateOrder = new UnicontaClient.Pages.CWCreateOrderFromProject(api, true, selectedItem);
cwCreateOrder.DialogTableId = 2000000053;
#endif
cwCreateOrder.Closed += async delegate
{
if (cwCreateOrder.DialogResult == true)
{
busyIndicator.BusyContent = Uniconta.ClientTools.Localization.lookup("LoadingMsg");
busyIndicator.IsBusy = true;
var debtorOrderInstance = api.CompanyEntity.CreateUserType <ProjectInvoiceProposalClient>();
var invoiceApi = new Uniconta.API.Project.InvoiceAPI(api);
var result = await invoiceApi.CreateOrderFromProject(debtorOrderInstance, selectedItem._Number, CWCreateOrderFromProject.InvoiceCategory, CWCreateOrderFromProject.GenrateDate,
CWCreateOrderFromProject.FromDate, CWCreateOrderFromProject.ToDate, cwCreateOrder.ProjectTask, cwCreateOrder.ProjectWorkspace);
busyIndicator.IsBusy = false;
if (result != ErrorCodes.Succes)
{
if (result == ErrorCodes.NoLinesToUpdate)
{
var message = string.Format("{0}. {1}?", Uniconta.ClientTools.Localization.lookup(result.ToString()), string.Format(Uniconta.ClientTools.Localization.lookup("CreateOBJ"), Uniconta.ClientTools.Localization.lookup("InvoiceProposal")));
var res = UnicontaMessageBox.Show(message, Uniconta.ClientTools.Localization.lookup("Message"), UnicontaMessageBox.YesNo);
if (res == MessageBoxResult.Yes)
{
debtorOrderInstance.SetMaster(selectedItem);
debtorOrderInstance._PrCategory = CWCreateOrderFromProject.InvoiceCategory;
debtorOrderInstance._NoItemUpdate = true;
var er = await api.Insert(debtorOrderInstance);
if (er == ErrorCodes.Succes)
{
ShowOrderLines(debtorOrderInstance);
}
}
}
else
{
UtilDisplay.ShowErrorCode(result);
}
}
else
{
ShowOrderLines(debtorOrderInstance);
}
}
};
cwCreateOrder.Show();
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
new ProjectClient();
try
{
await ProjectClient.DeleteProjectAsync(id);
return(RedirectToAction("Index"));
} catch (Exception)
{
return(RedirectToAction("Error"));
}
}
async void setTask(ProjectClient project)
{
if (project != null)
{
editrow.taskSource = project.Tasks ?? await project.LoadTasks(api);
}
else
{
editrow.taskSource = api.GetCache(typeof(Uniconta.DataModel.ProjectTask));
}
editrow.NotifyPropertyChanged("TaskSource");
leFollows.ItemsSource = editrow.TaskSource;
}
public async System.Threading.Tasks.Task <ActionResult> Edit(int id)
{
new ProjectClient();
new TaskClient();
var task = await TaskClient.GetTaskAsync(id);
var project = await ProjectClient.GetProjectAsync(task.ProjectID);
ViewBag.project = project;
return(View(task));
}
public IndexModel(
ILogger <IndexModel> logger,
ProjectClient projectClient,
ToDoItemClient todoClient,
TeamDirectoryClient teamDirectoryClient,
CalendarClient calendarClient)
{
_logger = logger;
_projectClient = projectClient;
_todoClient = todoClient;
_teamDirectoryClient = teamDirectoryClient;
_calendarClient = calendarClient;
}
void CopyRecord(ProjectClient selectedItem)
{
if (selectedItem == null)
{
return;
}
var project = Activator.CreateInstance(selectedItem.GetType()) as ProjectClient;
CorasauDataGrid.CopyAndClearRowId(selectedItem, project);
var parms = new object[2] {
project, false
};
AddDockItem(TabControls.ProjectPage2, parms, Uniconta.ClientTools.Localization.lookup("Project"), "Add_16x16.png");
}
public async System.Threading.Tasks.Task <ActionResult> Index(int projectId)
{
new ProjectClient();
new TaskClient();
var tasks = await TaskClient.GetTasksAsync(projectId);
var project = await ProjectClient.GetProjectAsync(projectId);
ViewBag.tasks = tasks;
ViewBag.projectId = projectId;
ViewBag.project = project;
return(View(tasks));
}