public ApplicationCategory()
{
Id = GuidComb.GenerateComb();
Posts = new List <ApplicationPost>();
CreatedDate = DateTime.Now;
UpdatedDate = DateTime.Now;
}
public async Task Publish(IEnumerable <NewReviewDiscussion> discussions, Dictionary <string, Guid> newCommentsMap, Dictionary <string, Guid> newDiscussionsMap)
{
foreach (var discussion in discussions)
{
var commentId = GuidComb.Generate();
var discussionId = GuidComb.Generate();
newCommentsMap[discussion.TemporaryId] = commentId;
newDiscussionsMap[discussion.TemporaryId] = discussionId;
var review = _reviewForRevision(discussion.TargetRevisionId);
_sessionAdapter.Save(new ReviewDiscussion
{
Id = discussionId,
RevisionId = review.RevisionId,
State = discussion.State.AsCommentState(),
RootComment = new Comment
{
Id = commentId,
Content = discussion.Content,
PostedInReviewId = review.Id,
CreatedAt = DateTimeOffset.UtcNow
}
});
}
}
public void Rename(string newName)
{
if (newName != Name)
{
Apply(new EntityTypeRenamedEvent(EntityTypeId, newName, GuidComb.Generate()));
}
}
public ProcessClientOutboxMessageCommandV2HandlerTestsFixture()
{
Now = DateTime.UtcNow;
EndpointName = "SFA.DAS.NServiceBus";
Events = new List <object>
{
new FooEvent(Now.AddDays(-1)),
new BarEvent(Now)
};
TransportOperations = Events.Select(e => new TransportOperation(Guid.NewGuid(), e)).ToList();
ClientOutboxMessage = new ClientOutboxMessageV2(GuidComb.NewGuidComb(), EndpointName, TransportOperations);
SynchronizedStorageSession = new Mock <SynchronizedStorageSession>();
Context = new TestableMessageHandlerContext
{
MessageId = ClientOutboxMessage.MessageId.ToString(),
SynchronizedStorageSession = SynchronizedStorageSession.Object
};
Command = new ProcessClientOutboxMessageCommandV2();
ClientOutboxStorage = new Mock <IClientOutboxStorageV2>();
ClientOutboxStorage.Setup(o => o.GetAsync(ClientOutboxMessage.MessageId, SynchronizedStorageSession.Object)).ReturnsAsync(ClientOutboxMessage);
Handler = new ProcessClientOutboxMessageCommandV2Handler(ClientOutboxStorage.Object);
}
public async Task <string> Upload(byte[] buffer)
{
string fileExtension = "png";
Guid guid = GuidComb.GenerateComb();
return(await Upload(guid.ToString() + "." + fileExtension, buffer));
}
public async Task <string> Upload(IFormFile file)
{
string fileExtension = "png";
switch (file.ContentType)
{
case "image/gif":
fileExtension = "gif";
break;
case "image/jpeg":
fileExtension = "jpg";
break;
case "image/png":
fileExtension = "png";
break;
case "image/bmp":
fileExtension = "bmp";
break;
}
string url = string.Empty;
using (var stream = file.OpenReadStream())
{
Guid guid = GuidComb.GenerateComb();
url = await Upload(guid.ToString() + "." + fileExtension, stream);
}
return(url);
}
public async Task <string> Upload(HttpContent httpContent)
{
string fileExtension = "png";
switch (httpContent.Headers.ContentType.ToString())
{
case "image/gif":
fileExtension = "gif";
break;
case "image/jpeg":
fileExtension = "jpg";
break;
case "image/png":
fileExtension = "png";
break;
case "image/bmp":
fileExtension = "bmp";
break;
}
string url = string.Empty;
using (var stream = httpContent.ReadAsStreamAsync().Result)
{
Guid guid = GuidComb.GenerateComb();
url = await Upload(guid.ToString() + "." + fileExtension, stream);
}
return(url);
}
public ProcessOutboxMessageCommandHandlerTestsFixture()
{
Now = DateTime.UtcNow;
EndpointName = "SFA.DAS.NServiceBus";
Events = new List <Event>
{
new FooEvent {
Created = Now.AddDays(-1)
},
new BarEvent {
Created = Now
}
};
OutboxMessage = new OutboxMessage(GuidComb.NewGuidComb(), EndpointName, Events);
Context = new TestableMessageHandlerContext
{
MessageId = OutboxMessage.MessageId.ToString()
};
Command = new ProcessOutboxMessageCommand();
Outbox = new Mock <IOutbox>();
Outbox.Setup(o => o.GetAsync(OutboxMessage.MessageId)).ReturnsAsync(OutboxMessage);
Handler = new ProcessOutboxMessageCommandHandler(Outbox.Object);
}
public void Rename(string newName)
{
if (newName != Name)
{
Apply(new DomainRenamedEvent(DomainId, newName, GuidComb.Generate()));
}
}
public static Guid SetIdsForCustomInsert(this IValueSet valueSet)
{
var sequentialGuid = GuidComb.GenerateComb();
if (valueSet is ValueSet realValueSet)
{
realValueSet.ValueSetGuid = sequentialGuid;
realValueSet.ValueSetReferenceId = sequentialGuid.ToString();
}
else
{
throw new NotImplementedException("IValueSet must be instantiated as ValueSet in this implementation.");
}
foreach (var code in valueSet.ValueSetCodes.Cast <ValueSetCode>())
{
code.ValueSetGuid = sequentialGuid;
}
foreach (var count in valueSet.CodeCounts.Cast <ValueSetCodeCount>())
{
count.ValueSetGuid = sequentialGuid;
}
return(sequentialGuid);
}
public ProcessOutboxMessagesJobTestsFixture SetOutboxMessagesAwaitingDispatch()
{
OutboxMessages.Add(new OutboxMessage(GuidComb.NewGuidComb(), "SFA.DAS.NServiceBus.Foo"));
OutboxMessages.Add(new OutboxMessage(GuidComb.NewGuidComb(), "SFA.DAS.NServiceBus.Bar"));
return(this);
}
public ApplicationArticle()
{
Id = GuidComb.GenerateComb();
Comments = new List <ApplicationComment>();
Tags = new List <ApplicationTag>();
DateCreated = DateTime.Now;
}
public MembershipUser()
{
Id = GuidComb.GenerateComb();
// Default size of 100 for now, override with something else if required
MemberImageSize = 100;
}
public ClientOutboxPersisterV2TestsFixture()
{
Now = DateTime.UtcNow;
DateTimeService = new Mock <IDateTimeService>();
Settings = new Mock <ReadOnlySettings>();
Connection = new Mock <DbConnection>();
Transaction = new Mock <DbTransaction> {
CallBase = true
};
Command = new Mock <DbCommand>();
Parameters = new Mock <DbParameterCollection>();
ClientOutboxTransaction = new SqlClientOutboxTransaction(Connection.Object, Transaction.Object);
EndpointName = "SFA.DAS.NServiceBus";
Events = new List <object>
{
new FooEvent(Now.AddDays(-1)),
new BarEvent(Now)
};
TransportOperations = Events.Select(e => new TransportOperation(Guid.NewGuid(), e)).ToList();
TransportOperationsData = JsonConvert.SerializeObject(TransportOperations, new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.Auto
});
ClientOutboxMessage = new ClientOutboxMessageV2(GuidComb.NewGuidComb(), EndpointName, TransportOperations);
SynchronizedStorageSession = new Mock <SynchronizedStorageSession>();
SqlSession = SynchronizedStorageSession.As <ISqlStorageSession>();
OutboxMessages = new List <IClientOutboxMessageAwaitingDispatch>();
CancellationTokenSource = new CancellationTokenSource();
CancellationToken = CancellationTokenSource.Token;
DateTimeService.Setup(d => d.UtcNow).Returns(Now);
Parameters.Setup(p => p.Add(It.IsAny <DbParameter>()));
Command.SetupSet(c => c.CommandText = It.IsAny <string>());
Command.SetupSet(c => c.Transaction = It.IsAny <DbTransaction>());
Command.Protected().Setup <DbParameter>("CreateDbParameter").Returns(() =>
{
var parameter = new Mock <DbParameter> {
CallBase = true
};
parameter.SetupProperty(p => p.ParameterName);
parameter.SetupProperty(p => p.Value);
return(parameter.Object);
});
Command.Protected().Setup <DbParameterCollection>("DbParameterCollection").Returns(Parameters.Object);
Connection.Protected().Setup <DbTransaction>("BeginDbTransaction", IsolationLevel.Unspecified).Returns(Transaction.Object);
Connection.Protected().Setup <DbCommand>("CreateDbCommand").Returns(Command.Object);
Settings.Setup(s => s.Get <Func <DbConnection> >("SqlPersistence.ConnectionBuilder")).Returns(() => Connection.Object);
SqlSession.Setup(s => s.Connection).Returns(Connection.Object);
SqlSession.Setup(s => s.Transaction).Returns(Transaction.Object);
ClientOutboxStorage = new ClientOutboxPersisterV2(DateTimeService.Object, Settings.Object);
}
public ApplicationPost()
{
Id = GuidComb.GenerateComb();
Tags = new List <ApplictionTag>();
CreatedDate = DateTime.Now;
UpdatedDate = DateTime.Now;
Comments = new List <ApplicationComment>();
Image = "/Uploads/Posts/def.jpg";
}
public ClientOutboxCleanerTestsFixture SetClientOutboxMessagesAwaitingDispatch()
{
ClientOutboxMessages.Add(new ClientOutboxMessage(GuidComb.NewGuidComb(), "SFA.DAS.NServiceBus.Foo"));
ClientOutboxMessages.Add(new ClientOutboxMessage(GuidComb.NewGuidComb(), "SFA.DAS.NServiceBus.Bar"));
ClientOutboxMessageV2s.Add(new ClientOutboxMessageV2(GuidComb.NewGuidComb(), "SFA.DAS.NServiceBus.FooV2"));
ClientOutboxMessageV2s.Add(new ClientOutboxMessageV2(GuidComb.NewGuidComb(), "SFA.DAS.NServiceBus.BarV2"));
return(this);
}
public async Task <IActionResult> Add(AddDomainRequest request)
{
var id = GuidComb.Generate();
var command = new AddDomainCommand(id, request.Name);
await _addDomainCommandHandler.Handle(command);
return(Ok(id));
}
public OutboxTestsFixture()
{
Now = DateTime.UtcNow;
Connection = new Mock <DbConnection>();
UnitOfWorkContext = new Mock <IUnitOfWorkContext>();
Settings = new Mock <ReadOnlySettings>();
Transaction = new Mock <DbTransaction> {
CallBase = true
};
Command = new Mock <DbCommand>();
Parameters = new Mock <DbParameterCollection>();
OutboxTransaction = new OutboxTransaction(Transaction.Object);
EndpointName = "SFA.DAS.NServiceBus";
Events = new List <Event>
{
new FooEvent {
Created = Now.AddDays(-1)
},
new BarEvent {
Created = Now
}
};
EventsData = JsonConvert.SerializeObject(Events, new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.Auto
});
OutboxMessage = new OutboxMessage(GuidComb.NewGuidComb(), EndpointName, Events);
OutboxMessages = new List <IOutboxMessageAwaitingDispatch>();
Parameters.Setup(p => p.Add(It.IsAny <DbParameter>()));
Command.SetupSet(c => c.CommandText = It.IsAny <string>());
Command.SetupSet(c => c.Transaction = It.IsAny <DbTransaction>());
Command.Protected().Setup <DbParameter>("CreateDbParameter").Returns(() =>
{
var parameter = new Mock <DbParameter> {
CallBase = true
};
parameter.SetupProperty(p => p.ParameterName);
parameter.SetupProperty(p => p.Value);
return(parameter.Object);
});
Command.Protected().Setup <DbParameterCollection>("DbParameterCollection").Returns(Parameters.Object);
Connection.Protected().Setup <DbTransaction>("BeginDbTransaction", IsolationLevel.Unspecified).Returns(Transaction.Object);
Connection.Protected().Setup <DbCommand>("CreateDbCommand").Returns(Command.Object);
UnitOfWorkContext.Setup(c => c.Get <DbConnection>()).Returns(Connection.Object);
UnitOfWorkContext.Setup(c => c.Get <DbTransaction>()).Returns(Transaction.Object);
Settings.Setup(s => s.Get <string>("NServiceBus.Routing.EndpointName")).Returns(EndpointName);
Outbox = new Outbox(Connection.Object, UnitOfWorkContext.Object);
}
public Guid Create(ImageViewModel image)
{
if (image is null)
{
throw new ArgumentNullException(nameof(image));
}
var imageId = GuidComb.GenerateComb();
const string query =
@"
INSERT INTO [dbo].[Image]
(
[Id],
[FileName],
[FileSizeBytes],
[Height],
[Width],
[MediaType],
[IsDeleted]
)
VALUES
(
@imageId,
@fileName,
@fileSizeBytes,
@height,
@width,
@mediaType,
0
);
";
var commandDefinition = new CommandDefinition(query, new
{
imageId,
fileName = image.FileName,
fileSizeBytes = image.FileSizeBytes,
height = image.Height,
width = image.Width,
mediaType = image.MediaType
});
using (var dbConnection = _connectionFactory.CreateWriteOnlyConnection())
{
var affectedRows = dbConnection.Execute(commandDefinition);
if (affectedRows == 1)
{
return(imageId);
}
}
return(Guid.Empty);
}
public static RevisionFile FromDiff(FileDiff file)
{
return(new RevisionFile
{
Id = GuidComb.Generate(),
File = file.Path,
IsNew = file.NewFile,
IsDeleted = file.DeletedFile,
IsRenamed = file.RenamedFile
});
}
private void AddContactType()
{
ContactType ct = this.dm.CreateObject <ContactType>();
ct.Id = GuidComb.Generate();
this.dm.AddContactType(ct);
ContactTypeViewModel vm = new ContactTypeViewModel(ct);
this.AllContactTypes.Add(vm);
this.CurrentContactType = vm;
}
public async Task <IActionResult> Sentences(long Id, IFormFile InputFile)
{
var test = await _context.TestCases.Include(x => x.Sentences).SingleOrDefaultAsync(x => x.Id == Id);
if (test == null)
{
return(NotFound());
}
string controller = "upload";
string fileName = "";
String line = "";
String Todaysdate = DateTime.Now.ToString("dd-MMM-yyyy");
if (InputFile != null && InputFile.Length != 0)
{
string path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "files", controller, Todaysdate);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
fileName = GuidComb.GenerateComb() + Path.GetExtension(InputFile.FileName);
var filePath = Path.Combine(path, fileName);
using (var stream = new FileStream(filePath, FileMode.Create)) {
await InputFile.CopyToAsync(stream);
}
using (var sr = new StreamReader(filePath)) {
line = sr.ReadToEnd();
Console.WriteLine(line);
}
}
if (line != null)
{
int i = 0;
foreach (var item in line.Trim().Split("\n"))
{
if (i > 5)
{
break;
}
test.Sentences[i].UserId = _userManager.GetUserId(HttpContext.User);
test.Sentences[i++].Content = item.Trim();
}
}
test.UserId = _userManager.GetUserId(HttpContext.User);
_context.Entry(test).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(View(test));
}
public void AddCompany()
{
Company c = this.dm.CreateObject <Company>();
c.Id = GuidComb.Generate();
dm.AddCompany(c);
CompanyViewModel vm = new CompanyViewModel(c);
AllCompanys.Add(vm);
CurrentCompany = vm;
}
public void AddRank()
{
var c = this.dm.CreateObject <Rank>();
c.Id = GuidComb.Generate();
dm.AddRank(c);
var vm = new RankViewModel(c);
AllRanks.Add(vm);
CurrentRank = vm;
}
private void AddScienceStatus()
{
ScienceStatus ss = this.dm.CreateObject <ScienceStatus>();
ss.Id = GuidComb.Generate();
this.dm.AddScienceStatus(ss);
ScienceStatusViewModel vm = new ScienceStatusViewModel(ss);
this.AllScienceStatuses.Add(vm);
this.CurrentScienceStatus = vm;
}
private void AddScienceDegree()
{
ScienceDegree sd = this.dm.CreateObject <ScienceDegree>();
sd.Id = GuidComb.Generate();
this.dm.AddScienceDegree(sd);
ScienceDegreeViewModel vm = new ScienceDegreeViewModel(sd);
this.AllScienceDegrees.Add(vm);
this.CurrentScienceDegree = vm;
}
public void AddAbstractStatus()
{
var a = dm.CreateObject <AbstractStatus>();
a.Id = GuidComb.Generate();
dm.AddAbstractStatus(a);
var vm = new AbstractStatusViewModel(a);
AllAbstractStatuses.Add(vm);
CurrentAbstractStatus = vm;
}
public void AddUser()
{
User c = this.dm.CreateObject <User>();
c.Id = GuidComb.Generate();
dm.AddUser(c);
UserViewModel vm = new UserViewModel(c);
AllUsers.Add(vm);
CurrentUser = vm;
}
private void Add()
{
var obj = DataManager.Instance.CreateObject <BadgesDefault>();
obj.Id = GuidComb.Generate();
obj.RankId = DataManager.Instance.GetAllRanks().FirstOrDefault().Id;
obj.BadgeTypeId = DataManager.Instance.GetAllBadges().FirstOrDefault().Id;
DataManager.Instance.AddBadgesDefault(obj);
BadgesDefaultsCollection.Add(new ListBoxBadgeDefault(obj));
OnPropertyChanged("BadgesDefaultsCollection");
BadgeDefaultSelected = new ListBoxBadgeDefault(obj);
}
public void AddPaymentType()
{
PaymentType c = this.dm.CreateObject <PaymentType>();
c.Id = GuidComb.Generate();
dm.AddPaymentType(c);
PaymentTypeViewModel vm = new PaymentTypeViewModel(c);
AllPaymentTypes.Add(vm);
CurrentPaymentType = vm;
}
