/// <summary>
/// Permet de se loguer au WebService
/// </summary>
/// <param name="p">Dictionnaire contenant votre identifiant</param>
/// <returns>Valeurs de retour contenant votre mot de passe.
/// Il sera nécessaire pour le Logout et l'écriture de vos données</returns>
public WSR_Result Login(WSR_Params p)
{
string pseudo = null;
string password = null;
WSR_Result ret = null;
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret != null)
{
return(ret);
}
AccountError err = Account.Add(pseudo, out password);
switch (err)
{
case AccountError.Ok:
return(new WSR_Result(password, true));
case AccountError.KeyNullOrEmpty:
return(new WSR_Result(CodeRetPseudoObligatoire, String.Format(Properties.Resources.PseudoObligatoire)));
case AccountError.KeyExist:
return(new WSR_Result(CodeRetPseudoUtilise, String.Format(Properties.Resources.PseudoUtilise)));
default:
return(new WSR_Result(CodeRetErreurInterneService, String.Format(Properties.Resources.ErreurInterneService)));
}
}
/// <summary>
/// Permet de se loguer au WebService
/// </summary>
/// <param name="p">Dictionnaire contenant votre identifiant</param>
/// <returns>Valeurs de retour contenant votre mot de passe. Il sera nécessaire pour le Logout et l'écriture de vos données</returns>
public WSR_Result Login(WSR_Params p)
{
string pseudo = null;
string password = null;
WSR_Result ret = null;
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret != null)
{
return(ret);
}
AccountError err = Account.Add(pseudo, out password);
switch (err)
{
case AccountError.Ok:
return(new WSR_Result(password, true));
case AccountError.KeyNullOrEmpty:
return(new WSR_Result(CodeRet_PseudoObligatoire, Properties.Resources.PSEUDOOBLIGATOIRE));
case AccountError.KeyExist:
return(new WSR_Result(CodeRet_PseudoUtilise, Properties.Resources.PSEUDOUTILISE));
default:
return(new WSR_Result(CodeRet_ErreurInterneService, Properties.Resources.ERREURINTERNESERVICE));
}
}
private static WSR_Result VerifParamType <T>(WSR_Params p, string key, out T value) where T : class
{
object data = null;
value = null;
WSR_Result ret = VerifParamExist(p, key, out data);
if (ret != null)
{
return(ret);
}
if (p[key] != null)
{
try
{
value = p[key] as T; // Permet de vérifier le type
}
catch (Exception) { } // Il peut y avoir exception si le type est inconnu (type personnalisé qui n'est pas dans les références)
if (value == null)
{
return(new WSR_Result(CodeRetParamTypeInvalid, String.Format(Properties.Resources.ParamTypeInvalid, key)));
}
}
return(null);
}
/// <summary>
/// Permet de se loguer. Appel asynchrone
/// </summary>
/// <param name="cancel">Permet d'annuler le traitement en cours</param>
/// <returns>Résutat retourné par le WebService</returns>
public async Task <RdmDalWSRResult> LoginAsync(CancellationToken cancel)
{
if (IsLogged)
{
return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_Login, Properties.Resources.PSEUDODEJALOGUE));
}
else if (String.IsNullOrWhiteSpace(_pseudoConnect))
{
return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_PseudoObligatoire, Properties.Resources.PSEUDOOBLIGATOIRE));
}
WSR_Params p;
try
{
p = new WSR_Params()
{
{ "pseudo", _pseudoConnect }
};
}
catch (Exception ex) { return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_SerialisationParams, String.Format(Properties.Resources.SERIALISATIONPARAMS, ex.Message))); }
WSR_Result ret = await ConsumeWSR.Call(String.Concat(StringConnect, ADR_LOGIN), p, TypeSerializer.Json, cancel);
if (ret.IsSuccess)
{
lock (_verrou)
{
IsLogged = true;
Password = (string)ret.Data;
}
}
return(new RdmDalWSRResult(ret));
}
/// <summary>
/// Permet de se déloguer. Appel asynchrone
/// </summary>
/// <param name="cancel">Permet d'annuler le traitement en cours</param>
/// <returns>Résutat retourné par le WebService</returns>
public async Task <RdmDalWSRResult> LogoutAsync(CancellationToken cancel)
{
if (!IsLogged)
{
return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_Logout, Properties.Resources.PSEUDONONLOGUE));
}
else if (String.IsNullOrWhiteSpace(_pseudoConnect))
{
return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_PseudoObligatoire, Properties.Resources.PSEUDOOBLIGATOIRE));
}
else if (String.IsNullOrWhiteSpace(_password))
{
return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_PasswordObligatoire, Properties.Resources.PASSWORDOBLIGATOIRE));
}
WSR_Params p;
try
{
p = new WSR_Params()
{
{ "pseudo", _pseudoConnect }, { "password", _password }
};
}
catch (Exception ex) { return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_SerialisationParams, String.Format(Properties.Resources.SERIALISATIONPARAMS, ex.Message))); }
WSR_Result ret = await ConsumeWSR.Call(String.Concat(StringConnect, ADR_LOGOUT), p, TypeSerializer.Json, cancel);
// Même si l'appel au WebService échoue on place la connexion dans l'état déconnectée
IsLogged = false;
return(new RdmDalWSRResult(ret));
}
/// <summary>
/// Permet de lire les données associés à un compte utilisateur
/// </summary>
/// <param name="p">Dictionnaire contenant l'identifiant, le mot de passe et l'identifiant
/// du compte à lire</param>
/// <returns>Valeurs de retour</returns>
public WSR_Result DownloadData(WSR_Params p)
{
string pseudo = null;
string pwd = null;
string pseudoDownload = null;
object data = null;
WSR_Result ret = null;
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret == null)
{
ret = VerifParamType(p, "pwd", out pwd);
if (ret == null)
{
ret = VerifParamType(p, "pseudoDowload", out pseudoDownload);
if (ret == null)
{
AccountError err = Account.ReadData(pseudo, pwd, pseudoDownload, out data);
switch (err)
{
case AccountError.Ok:
return(new WSR_Result(data, false));
case AccountError.KeyNullOrEmpty:
return(new WSR_Result(CodeRet_PseudoObligatoire, Properties.Resources.PSEUDOOBLIGATOIRE));
case AccountError.PasswordNullOrEmpty:
return(new WSR_Result(CodeRet_PasswordObligatoire, Properties.Resources.PASSWORDOBLIGATOIRE));
case AccountError.keyDownloadNullOrEmpty:
return(new WSR_Result(CodeRet_PseudoDownloadObligatoire, Properties.Resources.PSEUDODOWNLOADOBLIGATOIRE));
case AccountError.keyNotFound:
return(new WSR_Result(CodeRet_Logout, Properties.Resources.PSEUDONONLOGUE));
case AccountError.PasswordWrong:
return(new WSR_Result(CodeRet_PasswordIncorrect, Properties.Resources.PASSWORDINCORRECT));
case AccountError.keyDownloadNotFound:
return(new WSR_Result(CodeRet_PseudoDownloadLogout, String.Format(Properties.Resources.PSEUDODOWNLOADNONLOGUE, pseudoDownload)));
default:
return(new WSR_Result(CodeRet_ErreurInterneService, Properties.Resources.ERREURINTERNESERVICE));
}
}
else
{
return(ret);
}
}
else
{
return(ret);
}
}
else
{
return(ret);
}
}
public static async Task <WSR_Result> ExecuteAsync(string adresse, WSR_Params wsr_params, TypeSerializer type)
{
WSR_Result wsr_results = new WSR_Result();
return(wsr_results = await ConsumeWSR.Call(adresse, wsr_params, type, CancellationToken.None));
//string result = string.Format("Error code : {0}, Error Message :{1}, Contient data :{2}", wsr_results.ErrorCode,wsr_results.ErrorMessage,wsr_results.Data);
//return result;
}
private async void cmdDecnx_Click(object sender, EventArgs e)
{
_CancellationAsync = new CancellationTokenSource();
WSR_Params p = new WSR_Params();
p.Add("pseudo", txtPseudo.Text);
p.Add("password", lstPseudo.Text);
WSR_Result r1 = await ConsumeWSR.Call(@"http://localhost:4000/Service.svc/Logout", p, TypeSerializer.Json, _CancellationAsync.Token);
}
/// <summary>
/// Permet de lire les données associées à un compte utilisateur
/// </summary>
/// <param name="p">Dictionnaire contenant votre identifiant, votre mot de passe
/// et l'identifiant du compte à lire</param>
/// <returns>Valeurs de retour contenant les données lues</returns>
public WSR_Result DownloadData(WSR_Params p)
{
string pseudo = null;
string password = null;
string pseudoDownload = null;
object data = null;
WSR_Result ret = null;
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret != null)
{
return(ret);
}
ret = VerifParamType(p, "password", out password);
if (ret != null)
{
return(ret);
}
ret = VerifParamType(p, "pseudoDownload", out pseudoDownload);
if (ret != null)
{
return(ret);
}
AccountError err = Account.ReadData(pseudo, password, pseudoDownload, out data);
switch (err)
{
case AccountError.Ok:
return(new WSR_Result(data, false));
case AccountError.KeyNullOrEmpty:
return(new WSR_Result(CodeRetPseudoObligatoire, String.Format(Properties.Resources.PseudoObligatoire)));
case AccountError.keyNotFound:
return(new WSR_Result(CodeRetPseudoNonLogue, String.Format(Properties.Resources.PseudoNonLogue)));
case AccountError.PasswordNullOrEmpty:
return(new WSR_Result(CodeRetPasswordObligatoire, String.Format(Properties.Resources.PasswordObligatoire)));
case AccountError.PasswordWrong:
return(new WSR_Result(CodeRetPasswordIncorrect, String.Format(Properties.Resources.PasswordIncorrect)));
case AccountError.keyDownloadNullOrEmpty:
return(new WSR_Result(CodeRetPseudoDownloadObligatoire, String.Format(Properties.Resources.PseudoDownloadObligatoire)));
case AccountError.keyDownloadNotFound:
return(new WSR_Result(CodeRetPseudoDownloadNonLogue, String.Format(Properties.Resources.PseudoDownloadNonLogue)));
default:
return(new WSR_Result(CodeRetErreurInterneService, String.Format(Properties.Resources.ErreurInterneService)));
}
}
public WSR_Result UploadData(WSR_Params p)
{
string pseudo = null;
string password = null;
object data = null;
WSR_Result ret = null;
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret != null)
{
return(ret);
}
ret = VerifParamType(p, "password", out password);
if (ret != null)
{
return(ret);
}
ret = VerifParamExist(p, "data", out data);
if (ret != null)
{
return(ret);
}
AccountError err = Account.WriteData(pseudo, password, data);
switch (err)
{
case AccountError.Ok:
ret = new WSR_Result();
break;
case AccountError.KeyNullOrEmpty:
ret = new WSR_Result(CodeRet_PseudoObligatoire, Properties.Resources.PSEUDOVIDE);
break;
case AccountError.PasswordNullOrEmpty:
ret = new WSR_Result(CodeRet_PasswordObligatoire, Properties.Resources.PWDVIDE);
break;
case AccountError.keyNotFound:
ret = new WSR_Result(CodeRet_ParamKeyInconnu, string.Format(Properties.Resources.PARAMKEYINCONNU, pseudo));
break;
case AccountError.PasswordWrong:
ret = new WSR_Result(CodeRet_PasswordIncorrect, Properties.Resources.PWDWRONG);
break;
default:
ret = new WSR_Result(CodeRet_ErreurInterneService, Properties.Resources.ERREURINTERNE);
break;
}
return(ret);
}
/// <summary>
/// Permet de se Déloguer du WebService
/// </summary>
/// <param name="p">Dictionnaire contenant votre identifiant et votre mot de passe></param>
/// <returns>Valeurs de retour</returns>
public WSR_Result Logout(WSR_Params p)
{
string pseudo = null;
string password = null;
WSR_Result ret = null;
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret != null)
{
return(ret);
}
//On verifie que le mot de passe est bien passé en paramètre
ret = VerifParamType(p, "password", out password);
if (ret != null)
{
return(ret);
}
//On efface le compte utilisateur de la liste des utlisateurs connectés et on renvoi un code erreur
AccountError err = Account.Remove(pseudo, password);
switch (err)
{
case AccountError.Ok:
ret = new WSR_Result();
break;
case AccountError.KeyNullOrEmpty:
ret = new WSR_Result(CodeRet_PseudoObligatoire, Properties.Resources.PSEUDOVIDE);
break;
//Mot de passe vide
case AccountError.PasswordNullOrEmpty:
ret = new WSR_Result(CodeRet_PasswordObligatoire, Properties.Resources.PWDVIDE);
break;
//Le compte utilisateur n'existe pas
case AccountError.keyNotFound:
ret = new WSR_Result(CodeRet_ParamKeyInconnu, string.Format(Properties.Resources.PARAMKEYINCONNU, pseudo));
break;
//Mot de passe erroné
case AccountError.PasswordWrong:
ret = new WSR_Result(CodeRet_PasswordIncorrect, Properties.Resources.PWDWRONG);
break;
default:
ret = new WSR_Result(CodeRet_ErreurInterneService, Properties.Resources.ERREURINTERNE);
break;
}
return(ret);
}
private async void StartTimer(WSR_Params p)
{
System.Timers.Timer timer = new System.Timers.Timer();
timer.Interval = 1000;
WSR_Result r = await ConsumeWSR.Call(@"http://localhost:4000/Service.svc/GetPseudos", p, TypeSerializer.Json, _CancellationAsync.Token);
List <string> lst = new List <string>();
lst = (List <string>)r.Data;
lstPseudo.DataSource = lst;
timer.Start();
}
private static WSR_Result VerifParamExist(WSR_Params p, string key, out object data)
{
data = null;
if (!p.ContainsKey(key))
{
return(new WSR_Result(CodeRetParamKeyInconnu, String.Format(Properties.Resources.ParamKeyInconnu, key)));
}
data = p.GetValueSerialized(key);
return(null);
}
static void Main(string[] args)
{
Console.BackgroundColor = ConsoleColor.White;
Console.Clear();
Console.ForegroundColor = ConsoleColor.Magenta;
WSR_Params p = new WSR_Params();
/*p.Add("pseudo", "titi");
* Response("Login", p);*/
Response("GetPseudos", p);
Console.ReadKey();
}
/// <summary>
/// Permet d'obtenir la liste des utilisateurs logués au WebService
/// </summary>
/// <param name="p">Dictionnaire contenant votre identifiant et votre mot de passe</param>
/// <returns>Valeurs de retour contenant la liste des utilisateurs connectés</returns>
public WSR_Result GetPseudos(WSR_Params p)
{
string pseudo = null;
string password = null;
List <string> lstKeys = null;
WSR_Result ret = null;
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret != null)
{
return(ret);
}
ret = VerifParamType(p, "password", out password);
if (ret != null)
{
return(ret);
}
AccountError err = Account.GetKeys(pseudo, password, out lstKeys);
switch (err)
{
case AccountError.Ok:
//on renvoi la liste des utilisateurs, sérialisée
ret = new WSR_Result(lstKeys, true);
break;
case AccountError.KeyNullOrEmpty:
ret = new WSR_Result(CodeRet_PseudoObligatoire, Properties.Resources.PSEUDOVIDE);
break;
case AccountError.PasswordNullOrEmpty:
ret = new WSR_Result(CodeRet_PasswordObligatoire, Properties.Resources.PWDVIDE);
break;
case AccountError.keyNotFound:
ret = new WSR_Result(CodeRet_ParamKeyInconnu, string.Format(Properties.Resources.PARAMKEYINCONNU, pseudo));
break;
case AccountError.PasswordWrong:
ret = new WSR_Result(CodeRet_PasswordIncorrect, Properties.Resources.PWDWRONG);
break;
default:
ret = new WSR_Result(CodeRet_ErreurInterneService, Properties.Resources.ERREURINTERNE);
break;
}
return(ret);
}
/// <summary>
/// Permet d'écrire des données associées à votre compte utilisateur
/// </summary>
/// <param name="p">Dictionnaire contenant votre identifiant,votre mot de passe et les données à écrire</param>
/// <returns>Valeurs de retour</returns>
public WSR_Result UploadData(WSR_Params p)
{
string pseudo = null;
string password = null;
object data = null;
WSR_Result ret = null;
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret != null)
{
return(ret);
}
ret = VerifParamType(p, "password", out password);
if (ret != null)
{
return(ret);
}
ret = VerifParamExist(p, "data", out data); // Pas de vérification de type, il peut être personnalisé.
if (ret != null)
{
return(ret);
}
AccountError err = Account.WriteData(pseudo, password, data);
switch (err)
{
case AccountError.Ok:
return(new WSR_Result());
case AccountError.KeyNullOrEmpty:
return(new WSR_Result(CodeRetPseudoObligatoire, String.Format(Properties.Resources.PseudoObligatoire)));
case AccountError.keyNotFound:
return(new WSR_Result(CodeRetPseudoNonLogue, String.Format(Properties.Resources.PseudoNonLogue)));
case AccountError.PasswordNullOrEmpty:
return(new WSR_Result(CodeRetPasswordObligatoire, String.Format(Properties.Resources.PasswordObligatoire)));
case AccountError.PasswordWrong:
return(new WSR_Result(CodeRetPasswordIncorrect, String.Format(Properties.Resources.PasswordIncorrect)));
default:
return(new WSR_Result(CodeRetErreurInterneService, String.Format(Properties.Resources.ErreurInterneService)));
}
}
/// <summary>
/// Permet d'écrire des données associées à votre compte utilisateur
/// </summary>
/// <param name="p">Dictionnaire contenant votre identifiant, votre mot de passe et les données à écrire</param>
/// <returns>Valeurs de retour</returns>
public WSR_Result UploadData(WSR_Params p)
{
string pseudo = null;
string password = null;
object data = null;
WSR_Result ret = null;
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret != null)
{
return(ret);
}
ret = VerifParamType(p, "password", out password);
if (ret != null)
{
return(ret);
}
ret = VerifParamExist(p, "data", out data); // Pas de vérification de type. Les data sont stocké sous forme sérialisés. Pas besoin de connaître le type.
if (ret != null)
{
return(ret);
}
AccountError err = Account.WriteData(pseudo, password, data);
switch (err)
{
case AccountError.Ok:
return(new WSR_Result());
case AccountError.KeyNullOrEmpty:
return(new WSR_Result(CodeRet_PseudoObligatoire, Properties.Resources.PSEUDOOBLIGATOIRE));
case AccountError.PasswordNullOrEmpty:
return(new WSR_Result(CodeRet_PasswordObligatoire, Properties.Resources.PASSWORDOBLIGATOIRE));
case AccountError.keyNotFound:
return(new WSR_Result(CodeRet_Logout, Properties.Resources.PSEUDONONLOGUE));
case AccountError.PasswordWrong:
return(new WSR_Result(CodeRet_PasswordIncorrect, Properties.Resources.PASSWORDINCORRECT));
default:
return(new WSR_Result(CodeRet_ErreurInterneService, Properties.Resources.ERREURINTERNESERVICE));
}
}
public static async void Response(string resource, WSR_Params p)
{
_CancellationAsync = new CancellationTokenSource();
WSR_Result r = await ConsumeWSR.Call(@"http://localhost:4000/Service.svc/" + resource, p, TypeSerializer.Json, _CancellationAsync.Token);
List <string> lst = (List <string>)r.Data;
foreach (string item in lst)
{
Console.WriteLine(item);
}
//Console.WriteLine("mot de passe : " + r.Data);
}
private async void cmdCnx_Click(object sender, EventArgs e)
{
_CancellationAsync = new CancellationTokenSource();
WSR_Params p = new WSR_Params();
p.Add("pseudo", txtPseudo.Text);
WSR_Result r1 = await ConsumeWSR.Call(@"http://*****:*****@"http://localhost:4000/Service.svc/GetPseudos", p, TypeSerializer.Json, _CancellationAsync.Token);
*
* List<string> lst = new List<string>();
* lst = (List<string>)r2.Data;
* lstPseudo.DataSource = lst;*/
}
/// <summary>
/// Download des données à partir du cloud. Appel asynchrone
/// </summary>
/// <param name="pseudoDownload">Le pseudo dont on veut récupérer les données</param>
/// <param name="cancel">Permet d'annuler le traitement en cours</param>
/// <returns>Résutat retourné par le WebService</returns>
public async Task <RdmDalWSRResult> DownloadDataAsync(string pseudoDownload, CancellationToken cancel)
{
if (!IsLogged)
{
return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_Logout, Properties.Resources.PSEUDONONLOGUE));
}
else if (String.IsNullOrWhiteSpace(_pseudoConnect))
{
return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_PseudoObligatoire, Properties.Resources.PSEUDOOBLIGATOIRE));
}
else if (String.IsNullOrWhiteSpace(_password))
{
return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_PasswordObligatoire, Properties.Resources.PASSWORDOBLIGATOIRE));
}
else if (String.IsNullOrWhiteSpace(pseudoDownload))
{
return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_PseudoDownloadObligatoire, Properties.Resources.PSEUDODOWNLOADOBLIGATOIRE));
}
WSR_Params p;
try
{
p = new WSR_Params()
{
{ "pseudo", _pseudoConnect }, { "password", _password }, { "pseudoDownload", pseudoDownload }
};
}
catch (Exception ex) { return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_SerialisationParams, String.Format(Properties.Resources.SERIALISATIONPARAMS, ex.Message))); }
WSR_Result ret = await ConsumeWSR.Call(String.Concat(StringConnect, ADR_DOWNLOADDATAS), p, TypeSerializer.Json, cancel);
// On peut avoir été déconnecté depuis... (Multi-Threading)
if (!IsLogged)
{
return(new RdmDalWSRResult(RdmDalWSRResult.CodeRet_Logout, Properties.Resources.PSEUDONONLOGUE));
}
else if (ret.ErrorCode == CodeRet_RDMService_Logout)
{
IsLogged = false;
}
return(new RdmDalWSRResult(ret));
}
/// <summary>
/// Permet d'obtenir la liste des utilisateurs logués au WebService
/// </summary>
/// <param name="p">Dictionnaire contenant votre identifiant et votre mot de passe</param>
/// <returns>Valeurs de retour contenant la liste des utilisateurs connectés</returns>
public WSR_Result GetPseudos(WSR_Params p)
{
string pseudo = null;
string password = null;
List <string> lstKeys = null;
WSR_Result ret = null;
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret != null)
{
return(ret);
}
ret = VerifParamType(p, "password", out password);
if (ret != null)
{
return(ret);
}
AccountError err = Account.GetKeys(pseudo, password, out lstKeys);
switch (err)
{
case AccountError.Ok:
return(new WSR_Result(lstKeys, true));
case AccountError.KeyNullOrEmpty:
return(new WSR_Result(CodeRetPseudoObligatoire, String.Format(Properties.Resources.PseudoObligatoire)));
case AccountError.keyNotFound:
return(new WSR_Result(CodeRetPseudoNonLogue, String.Format(Properties.Resources.PseudoNonLogue)));
case AccountError.PasswordNullOrEmpty:
return(new WSR_Result(CodeRetPasswordObligatoire, String.Format(Properties.Resources.PasswordObligatoire)));
case AccountError.PasswordWrong:
return(new WSR_Result(CodeRetPasswordIncorrect, String.Format(Properties.Resources.PasswordIncorrect)));
default:
return(new WSR_Result(CodeRetErreurInterneService, String.Format(Properties.Resources.ErreurInterneService)));
}
}
/// <summary>
/// Permet d'obtenir la liste des utilisateurs logués au WebService
/// </summary>
/// <param name="p">Dictionnaire contenant votre identifiant et votre mot de passe</param>
/// <returns>Valeurs de retour contenant la liste des utilisateurs connectés</returns>
public WSR_Result GetPseudos(WSR_Params p)
{
string pseudo = null;
string password = null;
List <string> lstKeys = null;
WSR_Result ret = null;
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret != null)
{
return(ret);
}
ret = VerifParamType(p, "password", out password);
if (ret != null)
{
return(ret);
}
AccountError err = Account.GetKeys(pseudo, password, out lstKeys);
switch (err)
{
case AccountError.Ok:
return(new WSR_Result(lstKeys, true));
case AccountError.KeyNullOrEmpty:
return(new WSR_Result(CodeRet_PseudoObligatoire, Properties.Resources.PSEUDOOBLIGATOIRE));
case AccountError.PasswordNullOrEmpty:
return(new WSR_Result(CodeRet_PasswordObligatoire, Properties.Resources.PASSWORDOBLIGATOIRE));
case AccountError.keyNotFound:
return(new WSR_Result(CodeRet_Logout, Properties.Resources.PSEUDONONLOGUE));
case AccountError.PasswordWrong:
return(new WSR_Result(CodeRet_PasswordIncorrect, Properties.Resources.PASSWORDINCORRECT));
default:
return(new WSR_Result(CodeRet_ErreurInterneService, Properties.Resources.ERREURINTERNESERVICE));
}
}
public void TestVerifParamTypeOK()
{
WSR_Params p = new WSR_Params();
string key = "paramString";
string param = "essai";
string value = null;
p.Add(key, param);
WSR_Result rExpected = new WSR_Result();
rExpected = null;
ServiceForUnitTest service = new ServiceForUnitTest();
WSR_Result rActual = new WSR_Result();
rActual = service.VerifParamTypeTest(p, key, out value);
Assert.AreEqual(rExpected, rActual);
}
public void TestVerifParamExistNotOK()
{
WSR_Params p = new WSR_Params();
string key = "paramString";
string param = "essai";
object data = null;
p.Add(key, param);
WSR_Result rExpected = new WSR_Result();
rExpected = null;
ServiceForUnitTest service = new ServiceForUnitTest();
WSR_Result rActual = new WSR_Result();
rActual = service.VerifParamExistTest <string>(p, "paramKo", out data);
Assert.AreNotEqual(rExpected, rActual);
}
static void Main(string[] args)
{
string login = "******";
WSR_Params wsr_params = new WSR_Params();
wsr_params.Add("pseudo", "toto");
Console.WriteLine(ExecuteAsync(login, wsr_params, TypeSerializer.Json).Result.Data);
wsr_params = new WSR_Params();
wsr_params.Add("pseudo", "titi");
Console.WriteLine(ExecuteAsync(login, wsr_params, TypeSerializer.Json).Result.Data);
wsr_params = new WSR_Params();
wsr_params.Add("pseudo", "titi");
Console.WriteLine(ExecuteAsync(login, wsr_params, TypeSerializer.Json).Result.Data);
string getUsers = "http://localhost:53494/ServiceRDM.svc/GetPseudos";
Console.WriteLine(ExecuteAsync(getUsers, wsr_params, TypeSerializer.Xml).Result);
Console.Read();
}
/// <summary>
/// Permet de se loguer au WebService
/// </summary>
/// <param name="p">Dictionnaire contenant votre identifiant</param>
/// <returns>Valeurs de retour contenant votre mot de passe. Il sera nécessaire pour le Logout et l'écriture de vos données</returns>
public WSR_Result Login(WSR_Params p)
{
string pseudo = null;
string password = null;
WSR_Result ret = null;
//On vérifie que le pseudo est bien passé en paramètres
ret = VerifParamType(p, "pseudo", out pseudo);
if (ret != null)
{
return(ret);
}
//On ajoute le pseudo dans la liste des utilisateurs, on récupère un mot de passe et on renvoi un code erreur
AccountError err = Account.Add(pseudo, out password);
switch (err)
{
//tout se passe bien
case AccountError.Ok:
ret = new WSR_Result(password, true);
break;
//Le pseudo passé est vide/null
case AccountError.KeyNullOrEmpty:
ret = new WSR_Result(CodeRet_PseudoObligatoire, Properties.Resources.PSEUDOVIDE);
break;
//Le pseudo passé existe déjà
case AccountError.KeyExist:
ret = new WSR_Result(CodeRet_PseudoUtilise, string.Format(Properties.Resources.KEYUTILISE, pseudo));
break;
default:
ret = new WSR_Result(CodeRet_ErreurInterneService, Properties.Resources.ERREURINTERNE);
break;
}
return(ret);
}
public WSR_Result VerifParamTypeTest <T>(WSR_Params p, string key, out T value) where T : class
{
return(VerifParamType(p, key, out value));
}
public WSR_Result VerifParamExistTest <T>(WSR_Params p, string key, out object data)
{
return(VerifParamExist(p, key, out data));
}
