Création d'un CRM avec Xamarin.Forms et Azure, partie 2

public [19659033] statique classe Constantes

{

// Remplacez les chaînes par votre point de terminaison Azure Mobile App.

}

public interface IDataStore

{

Task < bool > AddItemAsync (T item);

Task < bool > UpdateItemAsync (élément T);

[19659008] Task < bool > DeleteItemAsync (élément T);

Tâche < bool > PurgeAsync ();

Tâche GetItemAsync ( string id);

Task < string > GetIdAsync ( string name);

Task <IReadOnlyList > GetItemsAsync ( bool forceRefresh = false );

Task < bool > PullLatestAsync ();

Task < bool > SyncAsync ();

}

await DependencyService.Get <IDataStore > (). GetItemsAsync (forceRefresh);

private void SetupVacationGauge ()

{

// Vacation Radial Gauge

VacationGauge.StartAngle = 90;

VacationGauge.SweepAngle = 360;

VacationGauge.AxisRadiusFactor = 1;

[19659008] VacationLinearAxis.Maximum = vm.SelectedEmployee.VacationBalance;

VacationLinearAxis.StrokeThickness = 0 020]

VacationLinearAxis.ShowLabels = false ;

VacationRangesDefinition.StartThickness = 10;

VacationRangesDefinition.EndThickness = 10;

VacationRangesDefinition.EndThickness = 10;

VacationRange.To = vm.SelectedEmployee.VacationBalance;

VacationRange.Color = (Color) Application.Current.Resources [ "GrayBackgroundColor" ];

[19659008] VacationIndicator.Value = vm.SelectedEmployee.VacationUsed;

VacationIndicator.Fill = (Color) A pplication.Current.Resources [ "AccentColor" ];

VacationIndicator.StartThickness = 10;

VacationIndicator.EndThickness = 10;

VacationIndicator.Start.Cap = GaugeBarIndicator;

VacationIndicator.EndCap = GaugeBarIndicatorCap.Oval;

}

} ] Le même modèle est également utilisé pour les autres jauges.

Suppression d'un employé

Également sur la page des détails, nous fournissons un moyen pour l'utilisateur de supprimer l'élément. Cela se fait à l'aide d'un événement de commande du bouton Supprimer de la barre d'outils.

Cependant, la suppression d'un employé a des conséquences car les enregistrements de la table Commandes peuvent contenir des commandes avec l'ID de cet employé. Je dois d'abord vérifier s'ils sont associés à des commandes ouvertes et avertir l'utilisateur que la suppression de l'employé supprimera également les commandes.

Voici l'action de la commande dans EmployeeDetailViewModel:

 private async Task DeleteEmployeeAsync () 
 {
 if (this.SelectedEmployee == null) 
 {
 return; 
} 
 var result = await App.Current.MainPage.DisplayAlert ("Supprimer?", "Voulez-vous vraiment supprimer cet élément?", "Oui", "Non"); 
 if (! Result) 
 {
 return; 
} 
 try 
 {
 this.IsBusy = true; 
 // Do Referential Integrity Check 
 var orders = wait DependencyService.Get <IDataStore > (). GetItemsAsync (); 
 var matchingOrders = orders.Where (o => o.EmployeeId == this.SelectedEmployee.Id) .ToList (); 
 if (matchingOrders.Count> 0 ) 
 {
 var deleteAll = wait App.Current.MainPage.DisplayAlert ("!!! WARNING !!!", $ "Il y a des commandes dans la base de données pour {_vm? .SelectedEmployee .Nom}. If you delete this employee, you'll also delete all of the associated orders.rnnDo you wish to delete everything?", "Delete All", "Cancel");
            // Back out if user declines to delete associated orders
            if (!deleteAll)
                return;
            // Delete each associated Order
            foreach (var order in matchingOrders)
            {
                await DependencyService.Get<IDataStore>().DeleteItemAsync(order);
            }
        }
        // Lastly, delete the employee
        await DependencyService.Get<IDataStore>().DeleteItemAsync(this.SelectedEmployee);
    }
    catch (Exception ex)
    {
        // display error to user
    }
    finally
    {
        this.IsBusy = false;
    }
    await this.NavigateBackAsync();
}[19659446]

Note: There are other ways to handle this scenario. Deleting the related orders is a rather drastic measure. In a real-world app, you’re more likely to re-set the ID or use a nullable field for EmployeeID.

Editing an Employee
Now we’re ready for some editing! I could have built this so that the edit form is built into the details page. This is a common approach, however I wanted to also provide a way to add an employee with the same edit form. 
I decided that a separate EmployeeEditPage would be better so I can keep the page code more readable and keep responsibilities separated.
The same EmployeeDetailsPage toolbar that has the delete button also has buttons for Edit and New Order. They can all share the same view model Command, but invoke different operations depending on a predefined command parameter.

    <ToolbarItem Text="order"
                 IconImageSource="add_order.png"
                 Command="{Binding ToolbarCommand}"
                 CommandParameter="order" />
    <ToolbarItem Text="edit"
                 IconImageSource="edit.png"
                 Command="{Binding ToolbarCommand}"
                 CommandParameter="edit" />
    <<ToolbarItem Text="delete"
                 Icon="delete.png"
                 Command="{Binding ToolbarCommand}"
                 CommandParameter="delete" />
Here's the view model command ToolbarItemTapped Action that will navigate to the EmployeeEditPagethe OrderEditPage or delete. We pass the SelectedEmployee to the constructor of both options.
private async void ToolbarItemTapped(object obj)
{
    if (this.SelectedEmployee == null)
    {
        return;
    }
    switch (obj.ToString())
    {
        case "order":
            await this.NavigateForwardAsync(new OrderEditPage(this.SelectedEmployee));
            break;
        case "edit":
            await this.NavigateForwardAsync(new EmployeeEditPage(this.SelectedEmployee));
            break;
        case "delete":
            await this.DeleteEmployeeAsync();
            break;
    }
}
Here’s the EmployeeDetailPage at runtime on Windows 10: