/// <summary>
/// Process exception when excute Update
/// </summary>
/// <param name="ex">Exception</param>
/// <returns>UpdateDataResult<T></returns>
public UpdateDataResult <T> ProcessException <T>(NpgsqlException ex, UpdateDataResult <T> updateDataResult)
{
//Duplicate unique fields case
if (((PostgresException)ex).SqlState == "23505")
{
string[] fields = new string[] { };
string detail = ((PostgresException)ex).Detail;
string leftStr = detail.Split('=')[0];
string strFieldNames = leftStr.Split('(')[1].Split(')')[0];
string[] str = strFieldNames.Split(',');
fields = str.Select(p => p.Replace(@"""", "")?.Replace(@"\", "")).ToArray();
updateDataResult.Error = new ErrorAction()
{
ErrorType = DataActionErrorTypeEnum.DuplicateData,
Fields = fields
};
}
//Require fields are null
if (((PostgresException)ex).SqlState == "23502")
{
string[] fields = new string[1];
string message = ((PostgresException)ex).Message;
fields[0] = Regex.Split(message, @"\""")[1];
updateDataResult.Error = new ErrorAction()
{
ErrorType = DataActionErrorTypeEnum.MissingFields,
Fields = fields
};
}
return(updateDataResult);
}
/// <summary>
/// Update data to db
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tableName"></param>
/// <param name="Where"></param>
/// <param name="data"></param>
/// <returns></returns>
public UpdateDataResult <T> UpdateData <T>(string TableName, string StrWhere, List <object> InputParams, T data)
{
var type = typeof(T);
var pro = type.GetProperties().ToList();
var fieldList = pro.Select(p => new {
name = p.Name,
value = p.GetValue(data),
paramIndex = pro.IndexOf(p)
}).ToList();
var fields = string.Join(",", fieldList.Select(p => Globals.Compiler.GetQName(p.name)).ToArray());
var strPro = string.Join(",", fieldList.Select(p => @"""" + p.name + @"""" + "=" + ":p" + p.paramIndex).ToArray());
var tblName = Globals.Compiler.GetQName(TableName);
for (int i = 0; i < InputParams.Count; i++)
{
StrWhere = StrWhere.Replace("{" + i + "}", ":p" + (fieldList.Count + i).ToString());
}
string sql = string.Format("UPDATE {0} SET {1} WHERE {2}", tblName, strPro, StrWhere);
UpdateDataResult <T> updateDataResult = new UpdateDataResult <T>();
// array of fields in table
var arrField = fieldList.Select(p => p.value).ToArray();
// array of fields in WHERE clause
var arrInputParam = InputParams.ToArray();
// arr total field = array of fields in table + array of fields in WHERE clause
var arrTotalField = arrField.Concat(arrInputParam).ToArray();
updateDataResult = UpdateDatabase <T>(sql, arrTotalField);
return(updateDataResult);
}
/// <summary>
/// Update into table, DML statement will be excuted here
/// </summary>
/// <param name="sql">This is sql query to update data in to table in database</param>
/// <returns></returns>
public UpdateDataResult <T> UpdateDatabase <T>(string SQL, params object[] pars)
{
UpdateDataResult <T> updateDataResult = new UpdateDataResult <T>();
object result = null;
try
{
if (cnn.State != ConnectionState.Open)
{
cnn.Open();
}
NpgsqlCommand command = new NpgsqlCommand(SQL, cnn);
var paramIndex = 0;
foreach (var p in pars)
{
var paramName = string.Format(":p{0}", paramIndex);
command.CommandText = command.CommandText.Replace("{" + paramIndex.ToString() + "}", paramName);
var sqlParam = new NpgsqlParameter();
sqlParam.ParameterName = paramName;
if (p != null)
{
sqlParam.Value = p;
}
else
{
sqlParam.Value = DBNull.Value;
}
command.Parameters.Add(sqlParam);
paramIndex++;
}
result = command.ExecuteNonQuery();
//Update successfully
if (result != null)
{
updateDataResult.Error = new ErrorAction()
{
ErrorType = DataActionErrorTypeEnum.None
};
}
if (cnn.State != ConnectionState.Closed)
{
cnn.Close();
}
}
catch (NpgsqlException ex)
{
Utils utils = new Utils();
updateDataResult = utils.ProcessException <T>(ex, updateDataResult);
}
catch (Exception ex)
{
throw ex;
}
return(updateDataResult);
}
public void UpdateData_should_return_success_if_get_update_set_data_are_successful()
{
const string path = "zk/default";
var bytes = new byte[] { 0, 1, 1, 2, 3, 5, 8, 13 };
zooKeeperClient.GetDataAsync(Arg.Any <GetDataRequest>())
.Returns(GetDataResult.Successful(path, bytes, Stat));
zooKeeperClient.SetDataAsync(Arg.Any <SetDataRequest>()).Returns(SetDataResult.Successful(path, Stat));
zooKeeperClient.UpdateData(new UpdateDataRequest(path, dummyUpdate))
.Should()
.BeEquivalentTo(UpdateDataResult.Successful(path));
}
public void UpdateData_should_return_fail_without_retries_if_cant_read_data(ZooKeeperStatus errorStatus)
{
const string path = "zk/default";
zooKeeperClient.GetDataAsync(Arg.Any <GetDataRequest>()).Returns(GetDataResult.Unsuccessful(errorStatus, path, null));
zooKeeperClient.UpdateData(new UpdateDataRequest(path, dummyUpdate))
.Should()
.BeEquivalentTo(UpdateDataResult.Unsuccessful(errorStatus, path, null));
zooKeeperClient.ReceivedWithAnyArgs(1)
.GetDataAsync(Arg.Any <GetDataRequest>());
zooKeeperClient.DidNotReceiveWithAnyArgs()
.SetDataAsync(Arg.Any <SetDataRequest>());
}
public void UpdateData_should_return_false_after_one_attempt_if_set_data_fails(ZooKeeperStatus failFastStatus)
{
const string path = "zk/default";
var bytes = new byte[] { 0, 1, 1, 2, 3, 5, 8, 13 };
zooKeeperClient.GetDataAsync(Arg.Any <GetDataRequest>())
.Returns(GetDataResult.Successful(path, bytes, Stat));
zooKeeperClient.SetDataAsync(Arg.Any <SetDataRequest>())
.Returns(SetDataResult.Unsuccessful(failFastStatus, path, null));
zooKeeperClient.UpdateData(new UpdateDataRequest(path, dummyUpdate))
.Should()
.BeEquivalentTo(UpdateDataResult.Unsuccessful(failFastStatus, path, null));
zooKeeperClient.ReceivedWithAnyArgs(1).SetDataAsync(Arg.Any <SetDataRequest>());
}
/// <summary>
/// <para>Trying to update node data with optimistic concurrency strategy according to given <paramref name="request"/>.</para>
/// <para>Check returned <see cref="UpdateDataResult"/> to see if operation was successful.</para>
/// </summary>
public static async Task <UpdateDataResult> UpdateDataAsync(this IZooKeeperClient zooKeeperClient, UpdateDataRequest request)
{
try
{
for (var i = 0; i < request.Attempts; i++)
{
var readResult = await zooKeeperClient.GetDataAsync(new GetDataRequest(request.Path)).ConfigureAwait(false);
if (!readResult.IsSuccessful)
{
return(UpdateDataResult.Unsuccessful(readResult.Status, readResult.Path, readResult.Exception));
}
var newData = request.Update(readResult.Data);
if (ByteArrayKey.Equals(readResult.Data, newData))
{
return(UpdateDataResult.Successful(readResult.Path));
}
var setDataRequest = new SetDataRequest(request.Path, newData)
{
Version = readResult.Stat.Version
};
var updateResult = await zooKeeperClient.SetDataAsync(setDataRequest).ConfigureAwait(false);
if (updateResult.Status == ZooKeeperStatus.VersionsMismatch)
{
continue;
}
return(updateResult.IsSuccessful ? UpdateDataResult.Successful(updateResult.Path) : UpdateDataResult.Unsuccessful(updateResult.Status, updateResult.Path, updateResult.Exception));
}
return(UpdateDataResult.Unsuccessful(ZooKeeperStatus.VersionsMismatch, request.Path, null));
}
catch (Exception e)
{
return(UpdateDataResult.Unsuccessful(ZooKeeperStatus.UnknownError, request.Path, e));
}
}
public void UpdateData_should_make_all_attempts_to_set_data_and_return_fail()
{
const string path = "zk/default";
const int attempts = 10;
var bytes = new byte[] { 0, 1, 1, 2, 3, 5, 8, 13 };
zooKeeperClient.GetDataAsync(Arg.Any <GetDataRequest>())
.Returns(GetDataResult.Successful(path, bytes, Stat));
zooKeeperClient.SetDataAsync(Arg.Any <SetDataRequest>())
.Returns(SetDataResult.Unsuccessful(ZooKeeperStatus.VersionsMismatch, path, null));
zooKeeperClient.UpdateData(new UpdateDataRequest(path, dummyUpdate)
{
Attempts = attempts
})
.Should()
.BeEquivalentTo(UpdateDataResult.Unsuccessful(ZooKeeperStatus.VersionsMismatch, path, null));
zooKeeperClient.ReceivedWithAnyArgs(attempts)
.SetDataAsync(Arg.Any <SetDataRequest>());
}
public void UpdateData_should_not_apply_update_when_bytes_not_changed()
{
const string path = "zk/default";
const int attempts = 10;
var bytes = new byte[] { 0, 1, 1, 2, 3, 5, 8, 13 };
var updatedBytes = new byte[] { 0, 1, 1, 2, 3, 5, 8, 13 };
byte[] UpdateFunc(byte[] oldBytes) =>
updatedBytes;
zooKeeperClient.GetDataAsync(Arg.Any <GetDataRequest>())
.Returns(GetDataResult.Successful(path, bytes, Stat));
zooKeeperClient.UpdateData(new UpdateDataRequest(path, UpdateFunc)
{
Attempts = attempts
})
.Should().BeEquivalentTo(UpdateDataResult.Successful(path));
zooKeeperClient
.DidNotReceiveWithAnyArgs()
.SetDataAsync(Arg.Any <SetDataRequest>());
}
/// <summary>
/// Updates the users.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="userList">The user list.</param>
/// <returns>The results of updating the users.</returns>
public UpdateDataResult UpdateUsers(SessionData session, List<UpdateUser> userList)
{
UpdateDataResult results = new UpdateDataResult();
foreach (UpdateUser updateUser in userList)
{
try
{
User existingUser = null;
if (!string.IsNullOrEmpty(updateUser.Id))
{
existingUser = this.workbenchManager.GetUser(session.UserId, updateUser.Id);
}
else if (!string.IsNullOrEmpty(updateUser.Username))
{
var search = new UserSearchCriteria
{
Usernames = new List<string>
{
updateUser.Username
}
};
UserList users = this.workbenchManager.FindUsers(session.UserId, search);
if (users.Count >= 1)
{
existingUser = users.First();
}
}
if (existingUser == null)
{
results.AddNotification(updateUser, updateUser.Id ?? updateUser.Username, UpdateMessageType.Error, string.Format(UpdateUserMessages.UserNotFound, updateUser.Username));
continue;
}
bool updatedUserDetails = existingUser.MapUserData(updateUser);
RoleList roles = this.workbenchManager.GetRoleList(session.UserId);
bool updatedRoles = existingUser.UpdateRoles(updateUser, roles);
bool updatedProperties = existingUser.UpdateExtendedProperties(updateUser);
if (updatedUserDetails || updatedRoles || updatedProperties)
{
this.securityService.SaveUser(session, existingUser);
results.AddNotification(existingUser, existingUser.Username, UpdateMessageType.Information, string.Format(UpdateUserMessages.Success, existingUser.Username, existingUser.DisplayName));
}
else
{
results.AddNotification(existingUser, existingUser.Username, UpdateMessageType.Information, string.Format(UpdateUserMessages.NoChange, existingUser.Username, existingUser.DisplayName));
}
}
catch (Exception e)
{
results.AddNotification(updateUser, updateUser.Id ?? updateUser.Username, UpdateMessageType.Error, e.Message);
}
}
return results;
}
