public DALWSR_Result GetTopicByRubricAsync(int id, CancellationToken cancel)
{
string str = string.Concat(CnxString, ADR_GETTOPICSBYRUBRIC, id);
WSR_Result r = ConsumeWSR.Call(str, "GET", null, TypeSerializer.Json, cancel);
return(new DALWSR_Result(r));
}
/// <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)));
}
}
public DALWSR_Result GetListTrainings(CancellationToken cancel)
{
string str = string.Concat(CnxString, ADR_GETTRAININGS);
WSR_Result r = ConsumeWSR.Call(str, "GET", null, TypeSerializer.Json, cancel);
return(new DALWSR_Result(r));
}
public DALWSR_Result GetListRubricsAsync(CancellationToken cancel)
{
string str = string.Concat(CnxString, ADR_GETRUBRICS);
WSR_Result r = ConsumeWSR.Call(str, "GET", null, TypeSerializer.Json, cancel);
return(new DALWSR_Result(r));
}
/// <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 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));
}
}
/// <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);
}
}
protected static WSR_Result VerifParamType <T>(WSR_Param 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(CodeRet_ParamTypeInvalid, String.Format(Properties.Resources.PARAMTYPEINVALID, key)));
}
}
return(null);
}
public DALWSR_Result GetUserByIdAsync(int id, CancellationToken cancel)
{
string str = string.Concat(CnxString, ADR_GETUSERBYID, id);
WSR_Result r = ConsumeWSR.Call(str, "GET", null, TypeSerializer.Json, cancel);
return(new DALWSR_Result(r));
}
public DALWSR_Result GetMessagesByUser(int id, CancellationToken cancel)
{
string str = string.Concat(CnxString, ADR_GETMESSAGESBYUSER, id);
WSR_Result r = ConsumeWSR.Call(str, "GET", null, TypeSerializer.Json, cancel);
return(new DALWSR_Result(r));
}
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);
}
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;
}
/// <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)));
}
}
internal RdmDalWSRResult(WSR_Result codeRet)
{
IsSuccess = codeRet.IsSuccess;
ErrorMessage = codeRet.ErrorMessage;
ErrorSourceFile = codeRet.ErrorSourceFile;
ErrorSourceLineNumber = codeRet.ErrorSourceLineNumber;
ErrorSourceMemberName = codeRet.ErrorSourceMemberName;
ErrorCode = codeRet.ErrorCode;
Data = codeRet.Data;
}
public DALWSR_Result LoginAsync(Token tokenAsk, CancellationToken cancel)
{
string str = string.Concat(CnxString, ADR_LOGIN);
WSR_Param p = new WSR_Param();
p.Add("token", tokenAsk);
WSR_Result r = ConsumeWSR.Call(str, "POST", p, TypeSerializer.Json, cancel);
return(new DALWSR_Result(r));
}
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);
}
public DALWSR_Result SaveStatus(StatusDTO status, Token tokenSend, CancellationToken cancel)
{
string str = string.Concat(CnxString, ADR_SAVESTATUS);
WSR_Param p = new WSR_Param()
{
{ "save", status }, { "token", tokenSend }
};
WSR_Result r = ConsumeWSR.Call(str, "POST", p, TypeSerializer.Json, cancel);
return(new DALWSR_Result(r));
}
public DALWSR_Result SaveUser(RegisteredDTO registered, Token tokenSend, CancellationToken cancel)
{
string str = string.Concat(CnxString, ADR_SAVEUSER);
WSR_Param p = new WSR_Param()
{
{ "save", registered }, { "token", tokenSend }
};
WSR_Result r = ConsumeWSR.Call(str, "POST", p, TypeSerializer.Json, cancel);
return(new DALWSR_Result(r));
}
public DALWSR_Result SaveTopic(TopicDTO topic, Token tokenSend, CancellationToken cancel)
{
string str = string.Concat(CnxString, ADR_SAVETOPIC);
WSR_Param p = new WSR_Param()
{
{ "save", topic }, { "token", tokenSend }
};
WSR_Result r = ConsumeWSR.Call(str, "POST", p, TypeSerializer.Json, cancel);
return(new DALWSR_Result(r));
}
public DALWSR_Result DeleteMessage(int id, Token tokenSend, CancellationToken cancel)
{
string str = string.Concat(CnxString, ADR_DELETEMESSAGE, id);
WSR_Param p = new WSR_Param()
{
{ "token", tokenSend }
};
WSR_Result r = ConsumeWSR.Call(str, "DELETE", p, TypeSerializer.Json, cancel);
return(new DALWSR_Result(r));
}
public DALWSR_Result SaveMessage(MessageDTO message, Token tokenSend, CancellationToken cancel)
{
string str = string.Concat(CnxString, ADR_SAVEMESSAGE);
WSR_Param p = new WSR_Param()
{
{ "save", message }, { "token", tokenSend }
};
WSR_Result r = ConsumeWSR.Call(str, "POST", p, TypeSerializer.Json, cancel);
return(new DALWSR_Result(r));
}
/// <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();
}
/// <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. 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));
}
}
/// <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)));
}
}
public WSR_Result GetUsers()
{
object data = null;
WSR_Result result = null;
if (result == null)
{
RegisteredDb db = new RegisteredDb();
data = db.GetAll();
return(new WSR_Result(data, true));
}
else
{
return(result);
}
}
public WSR_Result DeleteMessage(string idmessage)
{
object data = null;
WSR_Result result = null;
if (result == null)
{
MessageDb db = new MessageDb();
data = db.DeleteMessage(Convert.ToInt32(idmessage));
return(new WSR_Result(data, true));
}
else
{
return(result);
}
}
public WSR_Result GetMessagesByUser(string iduser)
{
object data = null;
WSR_Result result = null;
if (result == null)
{
MessageDb db = new MessageDb();
data = db.GetMessageByUser(Convert.ToInt32(iduser));
return(new WSR_Result(data, true));
}
else
{
return(result);
}
}
