public void ParametersBuilder_GetProcedureParameters_EmptyList()
{
var subject = new ParametersBuilder();
var output = subject.GetProcedureParameters();
Assert.AreEqual(0, output.Count());
}
public void KillAllConnections()
{
this.UnitOfWork.NonQueryDirect(
"Database_killAll",
ParametersBuilder.With("DBName", "Comical")
);
}
public IEnumerable <string> FindChecksumErrors()
{
var output = new ConcurrentBag <string>();
var models = this.UnitOfWork.GetDirect(
"Security_getAllRecords",
this.FetchRecordModel,
ParametersBuilder.With("table", this.TableName)
);
const string errorFormat = "Dígito Verificador Horizontal Inválido. Tabla '{0}'. Id '{1}'.";
Parallel.ForEach(models,
new ParallelOptions {
MaxDegreeOfParallelism = ComicalConfiguration.ChecksumCheckByModelDOP
},
model =>
{
var lazyVerify = new Lazy <string>(() => this.CalculateHorizontalVerifier(model.Values));
var verifierIsInvalid = String.IsNullOrWhiteSpace(model.Verifier) || lazyVerify.Value != model.Verifier;
if (verifierIsInvalid)
{
var message = String.Format(errorFormat, this.TableName, model.Id);
output.Add(message);
}
});
return(output.ToList());
}
public void OnStartAddon()
{
if (SelectedItem == null)
{
if (!TrySelectFirstPossibleItem())
{
return;
}
}
string parameters = ParametersBuilder.BuildStartParameter(SelectedItem, _allAddons);
// Change date for single selected item.
SelectedItem.ChangeLastUseDateToNow();
// Change date for all selected items.
foreach (var item in _allAddons)
{
if (item != SelectedItem && item.Selected)
{
item.ChangeLastUseDateToNow();
}
}
ProcessStart.StartProcess(parameters);
_history.UpdateHistoryFromList(Addons);
}
public Parameters GenerateParameters(CodeFileCSharp input, Settings pluginSettings, IMetadataReader metadataReader, ILogger logger, IFileGroup <CodeFileCSharp, GroupItemDetails> fileGroup = null)
{
if (string.IsNullOrEmpty(pluginSettings.AstDescriptionJsonFilePath))
{
throw new InvalidOperationException($"Setting {Settings.AstDescriptionJsonFilePathKey} should be provided.");
}
var path = pluginSettings.AstDescriptionJsonFilePath;
if (!Path.IsPathRooted(pluginSettings.AstDescriptionJsonFilePath))
{
path = Path.Combine(pluginSettings.BasePath, pluginSettings.AstDescriptionJsonFilePath);
}
var payload = File.ReadAllText(path);
var description = JsonConvert.DeserializeObject <Root>(payload);
var fixer = new InstanceReferenceFixer();
description = (Root)fixer.FixInstanceReferences(description);
var analyzer = new DescriptionAnalyzer(pluginSettings);
var astDescription = analyzer.Analyze(description);
var parametersBuilder = new ParametersBuilder(pluginSettings);
return(parametersBuilder.CreateParameters(astDescription));
}
public void Update(RoleWithPermissionsViewModel role)
{
var permissionTableName = "RolePermission";
this.UnitOfWork.Run(() =>
{
this.UnitOfWork.NonQuery(
"Role_update",
ParametersBuilder.With("Code", role.Code)
.And("Description", role.Description)
.And("Enabled", role.Enabled)
.And("Id", role.Id)
);
this.UnitOfWork.NonQuery(
"Role_deletePermissions",
ParametersBuilder.With("roleId", role.Id)
);
foreach (var permission in role.Permissions)
{
var relationshipId = this.UnitOfWork.Scalar(
"Role_newPermission",
ParametersBuilder.With("roleId", role.Id)
.And("permissionId", permission.Key)
).AsInt();
this.SetHorizontalVerifier(relationshipId, permissionTableName);
}
this.SetHorizontalVerifier(role.Id);
this.SetVerticalVerifierClosure();
this.SetVerticalVerifierClosure(permissionTableName);
});
}
public void SetUnderMaintenace(bool underMaintenance)
{
this.UnitOfWork.NonQueryDirect(
"DatabaseStatus_setMaintenance",
ParametersBuilder.With("DatabaseName", "Comical")
.And("UnderMaintenance", underMaintenance)
);
}
public void SetHasChecksumError(bool hasChecksumError)
{
this.UnitOfWork.NonQueryDirect(
"DatabaseStatus_setHasChecksumError",
ParametersBuilder.With("DatabaseName", "Comical")
.And("HasChecksumError", hasChecksumError)
);
}
public AliexpressSettingsProvider()
{
DomainName = "gw.api.alibaba.com";
Protocol = "param2";
Version = 2.ToString();
Namespace = "portals.open";
ParametersBuilder = new ParametersBuilder();
}
public void CallsDependenciesForSearchOperation()
{
Build();
TextBuilder.Verify(x => x.ParseV3Search(V3SearchRequest), Times.Once);
TextBuilder.Verify(x => x.Build(ParsedQuery), Times.Once);
ParametersBuilder.Verify(x => x.V3Search(V3SearchRequest, It.IsAny <bool>()), Times.Once);
}
public void SetParameters(ParametersBuilder parameters)
{
if (!(parameters is VoiceParametersBuilder))
{
throw new ArgumentException("Ошибка входного параметра трубектся параметр типа VoiceParametersBuilder");
}
this.parameters = (VoiceParametersBuilder)parameters;
}
public bool IsGrantedTo(int userId, string permissionCode)
{
var output = this.UnitOfWork.ScalarDirect(
"Permission_isGrantedToUser",
ParametersBuilder.With("userId", userId)
.And("permissionCode", permissionCode)
).AsBool();
return(output);
}
public User GetByLogin(string login)
{
var output = this.UnitOfWork.GetDirect(
"User_getByLogin",
this.FetchUser,
ParametersBuilder.With("Login", login)
).FirstOrDefault();
return(output);
}
protected void SetHorizontalVerifierDirectly(int id, string verifier)
{
var where = this.CreateWhere(id);
this.UnitOfWork.NonQueryDirect(
"Security_setVerifier",
ParametersBuilder.With("table", this.TableName)
.And("verifier", verifier)
.And("where", where)
);
}
protected void SetHorizontalVerifier(string verifier, string where, string table)
{
table = table ?? this.TableName;
this.UnitOfWork.NonQuery(
"Security_setVerifier",
ParametersBuilder.With("table", table)
.And("verifier", verifier)
.And("where", where)
);
}
public IEnumerable <Permission> GetByRole(int roleId)
{
var output = this.UnitOfWork.GetDirect(
"Permission_getByRole",
this.Fetch,
ParametersBuilder.With("roleId", roleId)
);
return(output);
}
public IEnumerable <string> GetBy(int userId)
{
var output = this.UnitOfWork.GetDirect(
"Permission_getByUser",
this.FetchPermissionCodes,
ParametersBuilder.With("userId", userId)
);
return(output);
}
public void BuildsSearchOperation()
{
var actual = Target.Autocomplete(AutocompleteRequest);
Assert.Equal(IndexOperationType.Search, actual.Type);
Assert.Same(Text, actual.SearchText);
Assert.Same(Parameters, actual.SearchParameters);
TextBuilder.Verify(x => x.Autocomplete(AutocompleteRequest), Times.Once);
ParametersBuilder.Verify(x => x.Autocomplete(AutocompleteRequest, It.IsAny <bool>()), Times.Once);
}
public Role GetById(int roleId)
{
var output = this.UnitOfWork.GetDirect(
"Role_getById",
this.FetchRole,
ParametersBuilder.With("Id", roleId)
).FirstOrDefault();
return(output);
}
public void DoBackup(string filepath, string createdBy)
{
this.UnitOfWork.NonQueryDirect("Database_doBackup_Comical_full",
ParametersBuilder.With("filepath", filepath)
);
this.UnitOfWork.NonQueryDirect("Backup_new",
ParametersBuilder.With("filepath", filepath)
.And("CreatedBy", createdBy));
}
public void CallsDependenciesForGetOperation()
{
ParsedQuery.Grouping[QueryField.PackageId] = new HashSet <string>(new[] { Id });
Build();
TextBuilder.Verify(x => x.ParseV3Search(V3SearchRequest), Times.Once);
TextBuilder.Verify(x => x.Build(It.IsAny <ParsedQuery>()), Times.Never);
ParametersBuilder.Verify(x => x.V3Search(It.IsAny <V3SearchRequest>(), It.IsAny <bool>()), Times.Never);
}
public DatabaseStatus Get()
{
var model = this.UnitOfWork.GetDirect(
"DatabaseStatus_get",
this.Fetch,
ParametersBuilder.With("DatabaseName", "Comical")
).First();
return(model);
}
public void Delete(int id)
{
this.UnitOfWork.Run(() =>
{
this.UnitOfWork.NonQuery(
"Role_delete",
ParametersBuilder.With("Id", id));
this.SetVerticalVerifierClosure();
});
}
public void DoRestore(int backupId)
{
var model = this.UnitOfWork.GetOneDirect("Backup_getOne",
this.Fetch,
ParametersBuilder.With("id", backupId));
this.UnitOfWork.NonQueryDirect("Security_doRestore",
ParametersBuilder.With("filepath", model.FilePath)
.And("dbname", "Comical")
);
}
protected IEnumerable <string> GetRecordValues(string where, string table = null)
{
table = table ?? this.TableName;
var values = this.UnitOfWork.Get(
"Security_getRecord",
this.FetchRecordValues,
ParametersBuilder.With("table", table)
.And("where", where)
).First();
return(values);
}
public void ParametersBuilder_SetupDbCommand_SetsParametersProperly()
{
var dbCommandMock = new Mock <IDbCommand>();
var dbParameter1Mock = new Mock <IDbDataParameter>();
var dbParameter2Mock = new Mock <IDbDataParameter>();
var dbParameterCollectionMock = new Mock <IDataParameterCollection>();
var myParameterList = new List <IDbDataParameter>();
var actualNames = new HashSet <string>();
var actualValues = new HashSet <object>();
var parametersQueue = new Queue <Mock <IDbDataParameter> >();
void SetupIDbDataParameter(Mock <IDbDataParameter> mock)
{
mock
.SetupSet(m => m.ParameterName = It.IsAny <string>())
.Callback <string>(value => actualNames.Add(value));
mock
.SetupSet(m => m.Value = It.IsAny <object>())
.Callback <object>(value => actualValues.Add(value));
parametersQueue.Enqueue(mock);
}
dbCommandMock
.Setup(m => m.CreateParameter())
.Returns(() => parametersQueue.Dequeue().Object);
dbCommandMock
.SetupGet(m => m.Parameters)
.Returns(() => dbParameterCollectionMock.Object);
SetupIDbDataParameter(dbParameter1Mock);
SetupIDbDataParameter(dbParameter2Mock);
dbParameterCollectionMock
.Setup(m => m.Add(It.IsAny <IDbDataParameter>()))
.Callback <object>(parameter => myParameterList.Add(parameter as IDbDataParameter));
var subject = ParametersBuilder.With("Param1", "string-value").And("Param2", 900);
subject.SetupDbCommand(dbCommandMock.Object);
Assert.AreEqual(2, myParameterList.Count);
Assert.IsTrue(actualNames.Contains("@Param1"));
Assert.IsTrue(actualNames.Contains("@Param2"));
Assert.IsTrue(actualValues.Contains("string-value"));
Assert.IsTrue(actualValues.Contains(900));
}
public void ParametersBuilder_With_WorksLikeAnd()
{
var subject = ParametersBuilder.With("Param1", 40).And("Param2", "string-value");
var output = subject.GetProcedureParameters().ToArray();
Assert.AreEqual(2, output.Count());
Assert.AreEqual("Param1", output[0].Name);
Assert.AreEqual("Param2", output[1].Name);
Assert.AreEqual(40, output[0].GetValue());
Assert.AreEqual("string-value", output[1].GetValue());
}
public void ChangeEnabled(int id, bool value)
{
this.UnitOfWork.Run(() =>
{
this.UnitOfWork.NonQuery(
"User_changeEnabled",
ParametersBuilder.With("id", id)
.And("Enabled", value)
);
this.SetHorizontalVerifier(id);
this.SetVerticalVerifier();
});
}
protected void InsertUserRoles(User model)
{
foreach (var role in model.Roles)
{
var id = this.UnitOfWork.Scalar(
"UserRole_new",
ParametersBuilder.With("UserId", model.Id)
.And("RoleId", role.Id)
).AsInt();
this.SetHorizontalVerifier(id, "UserRole");
}
this.SetVerticalVerifier("UserRole");
}
public int IncrementRetry(int id)
{
var output = this.UnitOfWork.Run(() =>
{
var retries = this.UnitOfWork.Scalar(
"User_incrementRetry",
ParametersBuilder.With("id", id)
).AsInt();
this.SetHorizontalVerifier(id);
this.SetVerticalVerifier();
return(retries);
});
return(output);
}
