public void fillObject(Domain.Role role)
{
foreach (UIElement el in this.panel.Children)
{
RoleItemPanel item = (RoleItemPanel)el;
String roleName = item.TextBox.Text;
if (String.IsNullOrEmpty(roleName))
{
continue;
}
Domain.Role roleItem = new Domain.Role()
{
name = roleName
};
if (item.Role != null)
{
item.Role.name = roleName;
role.UpdateChild(item.Role);
}
else
{
role.AddChild(roleItem);
}
}
}
public ActionResult Edit(Domain.Role role, FormCollection collection)
{
return(EditModel(role));
//JsonResult ret = new JsonResult();
//try
//{
// var editRole = db.Role.Find(role.ID);
// editRole.RName = role.RName;
// editRole.RCode = role.RCode;
// editRole.EditorID = (int)LoginUser.ID;
// editRole.EditingTime = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss");
// db.SaveChanges();
// ret.Data = JsonConvert.SerializeObject(new
// {
// status = 0,
// message = ""
// });
//}
//catch (Exception ex)
//{
// ret.Data = JsonConvert.SerializeObject(new
// {
// status = 1,
// message = ex.Message
// });
//}
//return ret;
}
/// <summary>
/// affiche le calculatedMeasure en edition
/// </summary>
/// <param name="table"></param>
public void DisplayRole(Domain.Role root)
{
this.panel.Children.Clear();
int index = 1;
if (root == null)
{
this.ActiveItemPanel = new RoleItemPanel(index);
this.ActiveItemPanel.rolePanel = this;
AddItemPanel(this.ActiveItemPanel);
return;
}
foreach (Domain.Role item in root.childrenListChangeHandler.Items)
{
RoleItemPanel itemPanel = new RoleItemPanel(item);
itemPanel.Index = index;
itemPanel.newButton.Visibility = System.Windows.Visibility.Hidden;
AddItemPanel(itemPanel);
index++;
}
this.ActiveItemPanel = new RoleItemPanel(index);
this.ActiveItemPanel.rolePanel = this;
AddItemPanel(this.ActiveItemPanel);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnValidateEdition()
{
String text = this.TextBox.Text;
if (rolePanel != null)
{
foreach (UIElement el in rolePanel.panel.Children)
{
RoleItemPanel item = (RoleItemPanel)el;
String roleName = item.TextBox.Text;
if (roleName.Equals(text) && item != this)
{
Util.MessageDisplayer.DisplayError("Duplicate Name", "There is another Target named: " + text);
this.TextBox.Text = null;
}
}
}
decimal amount;
bool valid = decimal.TryParse(text, out amount);
if (!valid)
{
return;
}
Domain.Role value = new Domain.Role();
SetValue(value);
}
public ActionResult Create(Domain.Role role, FormCollection collection)
{
return(CreateModel(role));
/*
* JsonResult ret = new JsonResult();
* try
* {
* role.CreatorID = (int)LoginUser.ID;
* role.CreationTime = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss");
*
* db.Role.Add(role);
* db.SaveChanges();
* ret.Data = JsonConvert.SerializeObject(new
* {
* status = 0,
* message = ""
* });
* }
* catch (Exception ex)
* {
* ret.Data = JsonConvert.SerializeObject(new
* {
* status = 1,
* message = ex.Message
* });
* }
* return ret;*/
}
public ActionResult Create()
{
var model = new Domain.Role();
var roleView = new Role();
roleView.InjectFrom(model);
return(View(roleView));
}
/// <summary>
/// Définit la valeur du TargetItem en cour d'édition
/// et affiche cette valeur dans le TextBox
/// </summary>
/// <param name="value">La valeur du TargetItem en cour d'édition</param>
public bool SetRoleItemValue(Domain.Role value)
{
if (this.ActiveItemPanel == null)
{
this.ActiveItemPanel = (RoleItemPanel)this.panel.Children[this.panel.Children.Count - 1];
}
this.ActiveItemPanel.SetValue(value);
return(true);
}
public void Display(Domain.Role item)
{
update = false;
this.Role = item;
if (item != null)
{
this.Index = item.position + 1;
}
this.TextBox.Text = item != null && !String.IsNullOrWhiteSpace(item.name) ? item.name : "";
update = true;
}
/// <summary>
/// Cette méthode permet d'afficher les données de l'objet à éditer
/// pour les afficher dans la vue.
/// </summary>
public void displayObject()
{
this.userMainPanel.Display(this.EditedObject);
if (UserService == null)
{
return;
}
Domain.Role rootRole = UserService.RoleService.getRootRole();
//this.userMainPanel.RelationPanel.FillRoles(rootRole.childrenListChangeHandler.Items.ToList());
//this.userMainPanel.RelationPanel.FillUsers(UserService.getUsersRelation(this.EditedObject));
}
public Domain.Role GetDomainObject(bool getChildrenObject)
{
Domain.Role dto = new Domain.Role();
dto.ID = this.RoleID;
dto.Name = this.Name;
dto.Description = this.Description;
if (getChildrenObject)
{
dto.Dimensions = Dimension.GetDimensions(this.RoleID, getChildrenObject);
}
return dto;
}
//met a jour la selection liste en cours
private void UpdateSelectionList(Domain.Role selectedMeasure)
{
if (!selectedRoles.ContainsKey(selectedMeasure))
{ // add
selectedRoles.Remove(selectedMeasure);
selectedRoles.Add(selectedMeasure, selectedRoles.Count + 1);
}
else
{ // remove
selectedRoles.Remove(selectedMeasure);
}
}
private void OnExitEditMode(object sender, EO.Wpf.EditItemEventArgs e)
{
try
{
if (e.Item is Kernel.Domain.Role)
{
Kernel.Domain.Role editedMeasure = (Kernel.Domain.Role)e.Item;
string name = e.Text.Trim();
Kernel.Domain.Role validName = ValidateName(editedMeasure, name);
if (validName == null)
{
e.Canceled = true;
return;
}
if (editedMeasure.IsDefault)
{
if (name.ToUpper() != Label_DEFAULT_ROLE.ToUpper())
{
Kernel.Domain.Role addedNode = new Domain.Role();
addedNode.name = name;
editedMeasure.name = Label_DEFAULT_ROLE;
editedMeasure.parent.UpdateChild(editedMeasure);
addedNode = ValidateName(addedNode, name);
AddNode(null, addedNode.name);
e.Canceled = true;
}
}
else
{
Kernel.Domain.Role valid = ValidateName(editedMeasure, name);
editedMeasure.name = valid.name;
editedMeasure.parent.UpdateChild(editedMeasure);
}
if (Changed != null)
{
Changed();
}
}
//The event must be canceled, otherwise the TreeView will
//set the TreeViewItem's Header to the new text
e.Canceled = true;
}
catch (Exception)
{
return;
}
}
public ActionResult Create(ViewModels.Role model)
{
if (ModelState.IsValid)
{
var dbModel = new Domain.Role();
dbModel.InjectFrom(model);
//roleRepository.Add(dbModel);
roleService.AddRole(dbModel);
//transform the object
//unitOfWork.Commit();
return(RedirectToAction("Index"));
}
return(View(model));
}
protected Kernel.Domain.Role GetNewTreeViewModel(Domain.Role value = null)
{
Kernel.Domain.Role role = new Kernel.Domain.Role();
role.name = "Role1";
if (Root != null)
{
Kernel.Domain.Role m = null;
int i = 1;
do
{
role.name = "Role" + i++;
m = (Kernel.Domain.Role)Root.GetChildByName(role.name);
}while (m != null);
}
return(role);
}
private DefaultUser()
{
Id = -1;
Name = "default";
Surname = "default";
Email = "default";
Password = "******";
RoleId = -1;
BirthDay = DateTime.Now;
LocalityId = -1;
SexualIdentity = "default";
Vizibility = "default";
Role = new Domain.Role()
{
Id = -1, Name = "default"
};
Locality = new Domain.Locality()
{
Id = -1, Name = "default"
};
}
public void SetValue(Domain.Role value)
{
added = false;
if (this.Role == null)
{
this.Role = new Domain.Role();
this.Role.SetPosition(Index - 1);
added = true;
}
//this.Role = value.GetCopy(this.Role);
//updateMeasureItemOperator();
added = setRoleItemAdded();
this.TextBox.Text = this.Role != null ? this.Role.name : "";
if (Added != null && added)
{
Added(this);
}
if (Updated != null && !added)
{
Updated(this);
}
}
/// <summary>
/// Construit une nouvelle instance de CalculatedMeasureItemPanel
/// </summary>
/// <param name="index">Index du panel</param>
/// <param name="item">TargetItem à afficher</param>
public RoleItemPanel(Domain.Role role)
: this()
{
Display(role);
}
public static Services.Roles.GetRole.GetRoleResponse GetRole(Services.Roles.GetRole.GetRoleRequest request)
{
Services.Roles.GetRole.GetRoleResponse response = new Services.Roles.GetRole.GetRoleResponse();
try
{
DocsPaVO.utente.Utente utente = null;
DocsPaVO.utente.InfoUtente infoUtente = null;
//Inizio controllo autenticazione utente
infoUtente = Utils.CheckAuthentication(request, "GetRole");
utente = BusinessLogic.Utenti.UserManager.getUtenteById(infoUtente.idPeople);
if (utente == null)
{
//Utente non trovato
throw new PisException("USER_NO_EXIST");
}
//Fine controllo autenticazione utente
if (string.IsNullOrEmpty(request.CodeRole) && string.IsNullOrEmpty(request.IdRole))
{
throw new PisException("REQUIRED_CODE_OR_ID_ROLE");
}
if (!string.IsNullOrEmpty(request.CodeRole) && !string.IsNullOrEmpty(request.IdRole))
{
throw new PisException("REQUIRED_ONLY_CODE_OR_ID_ROLE");
}
Domain.Role roleResponse = new Domain.Role();
Domain.Register[] registerResponse = null;
DocsPaVO.utente.Ruolo ruolo = null;
ArrayList registri = new ArrayList();
if (!string.IsNullOrEmpty(request.CodeRole))
{
ruolo = BusinessLogic.Utenti.UserManager.getRuoloByCodice(request.CodeRole);
}
else
{
if (!string.IsNullOrEmpty(request.IdRole))
{
//Id gruppo
ruolo = BusinessLogic.Utenti.UserManager.getRuoloByIdGruppo(request.IdRole);
}
}
if (ruolo != null)
{
registri = BusinessLogic.Utenti.RegistriManager.getListaRegistriRfRuolo(ruolo.systemId, string.Empty, string.Empty);
roleResponse.Code = ruolo.codiceRubrica;
roleResponse.Description = ruolo.descrizione;
roleResponse.Id = ruolo.idGruppo;
if (registri != null && registri.Count > 0)
{
registerResponse = new Domain.Register[registri.Count];
int i = 0;
foreach (DocsPaVO.utente.Registro reg in registri)
{
Domain.Register regTemp = new Domain.Register();
regTemp.Code = reg.codRegistro;
regTemp.Description = reg.descrizione;
regTemp.Id = reg.systemId;
if (!string.IsNullOrEmpty(reg.chaRF) && (reg.chaRF).Equals("1"))
{
regTemp.IsRF = true;
}
else
{
regTemp.IsRF = false;
}
if (!string.IsNullOrEmpty(reg.stato))
{
if (reg.stato.Equals("A"))
{
regTemp.State = "Open";
}
else
{
regTemp.State = "Closed";
}
}
registerResponse[i] = regTemp;
i++;
}
}
}
else
{
//Ruolo non trovato
throw new PisException("ROLE_NO_EXIST");
}
response.Role = roleResponse;
response.Role.Registers = registerResponse;
response.Success = true;
}
catch (PisException pisEx)
{
logger.ErrorFormat("PISException: {0}, {1}", pisEx.ErrorCode, pisEx.Description);
response.Error = new Services.ResponseError
{
Code = pisEx.ErrorCode,
Description = pisEx.Description
};
response.Success = false;
}
catch (Exception ex)
{
logger.ErrorFormat("Eccezione Generica: APPLICATION_ERROR, {0}", ex.Message);
response.Error = new Services.ResponseError
{
Code = "APPLICATION_ERROR",
Description = ex.Message
};
response.Success = false;
}
return(response);
}
public static Services.Roles.GetRoles.GetRolesResponse GetRoles(Services.Roles.GetRoles.GetRolesRequest request)
{
Services.Roles.GetRoles.GetRolesResponse response = new Services.Roles.GetRoles.GetRolesResponse();
try
{
DocsPaVO.utente.Utente utente = null;
DocsPaVO.utente.InfoUtente infoUtente = null;
//Inizio controllo autenticazione utente
infoUtente = Utils.CheckAuthentication(request, "GetRoles");
utente = BusinessLogic.Utenti.UserManager.getUtenteById(infoUtente.idPeople);
if (utente == null)
{
//Utente non trovato
throw new PisException("USER_NO_EXIST");
}
//Fine controllo autenticazione utente
if (string.IsNullOrEmpty(request.UserID))
{
throw new PisException("REQUIRED_USERID");
}
Domain.Role[] roleResponse = null;
DocsPaVO.utente.Utente utenteDaCercare = null;
ArrayList arrayRuoli = new ArrayList();
if (!string.IsNullOrEmpty(request.UserID))
{
utenteDaCercare = BusinessLogic.Utenti.UserManager.getUtente(request.UserID, Utils.GetIdAmministrazione(request.UserID));
}
else
{
throw new PisException("REQUIRED_USERID");
}
if (utenteDaCercare != null)
{
DocsPaVO.utente.InfoUtente infoUtenteDaCercare = new DocsPaVO.utente.InfoUtente(utenteDaCercare, Utils.GetRuoloPreferito(utenteDaCercare.idPeople));
arrayRuoli = BusinessLogic.Utenti.UserManager.getRuoliUtente(infoUtenteDaCercare.idPeople);
if (arrayRuoli != null && arrayRuoli.Count > 0)
{
roleResponse = new Domain.Role[arrayRuoli.Count];
int i = 0;
foreach (DocsPaVO.utente.Ruolo rol in arrayRuoli)
{
Domain.Role roleTemp = new Domain.Role();
roleTemp.Code = rol.codiceRubrica;
roleTemp.Description = rol.descrizione;
roleTemp.Id = rol.idGruppo;
roleResponse[i] = roleTemp;
i++;
}
}
else
{
throw new PisException("USER_NO_ROLES");
}
}
else
{
//Utente non trovato
throw new PisException("USER_NO_EXIST");
}
response.Roles = roleResponse;
response.Success = true;
}
catch (PisException pisEx)
{
logger.ErrorFormat("PISException: {0}, {1}", pisEx.ErrorCode, pisEx.Description);
response.Error = new Services.ResponseError
{
Code = pisEx.ErrorCode,
Description = pisEx.Description
};
response.Success = false;
}
catch (Exception ex)
{
logger.ErrorFormat("Eccezione Generica: APPLICATION_ERROR, {0}", ex.Message);
response.Error = new Services.ResponseError
{
Code = "APPLICATION_ERROR",
Description = ex.Message
};
response.Success = false;
}
return(response);
}
public bool Update(Domain.Role entity)
{
return(_roleRepository.Update(entity));
}
// GET: Role/Create
public ActionResult Create()
{
CreateAcion();
Domain.Role r = new Domain.Role();
return(View(r));
}
public void InitRelationPanel()
{
Domain.Role RootRole = userService.RoleService.getRootRole();
this.RelationPanel.FillUsers(userService.getUsersRelation(currentUser));
this.RelationPanel.FillRoles(userService.RoleService.getRolesRelation());
}
/// <summary>
/// Ajoute la valeur par défaut après avoir créer une role
/// </summary>
/// <param name="value">le parent de la role à créer</param>
/// <returns>la mesure créé</returns>
public Domain.Role addDefaultNode(Kernel.Domain.Role value = null)
{
Domain.Role r = AddNode(value);
return(r);
}
