static void Main()
{
CreateDatabase db = new CreateDatabase();
UserRepository userRepo = new UserRepository();
ConferenceRepository conferenceRepo = new ConferenceRepository();
EditionRepository editionRepo = new EditionRepository();
BinaryServerFormatterSinkProvider serverProv = new BinaryServerFormatterSinkProvider();
serverProv.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
BinaryClientFormatterSinkProvider clientProv = new BinaryClientFormatterSinkProvider();
IDictionary props = new Hashtable();
props["port"] = 55555;
TcpChannel channel = new TcpChannel(props, clientProv, serverProv);
ChannelServices.RegisterChannel(channel, false);
var server = new ServerImpl();
RemotingServices.Marshal(server, "Chat");
Console.WriteLine("Server started ...");
Console.WriteLine("Press <enter> to exit...");
Console.ReadLine();
}
public async Task <ListResultDto <EditionLookupDto> > GetEditionLookupAsync()
{
var editions = await EditionRepository.GetListAsync();
return(new ListResultDto <EditionLookupDto>(
ObjectMapper.Map <List <Edition>, List <EditionLookupDto> >(editions)
));
}
public async Task <EditionDto> CreateAsync(EditionCreateDto input)
{
var edition = await EditionManager.CreateAsync(input.DisplayName);
await EditionRepository.InsertAsync(edition);
return(ObjectMapper.Map <Edition, EditionDto>(edition));
}
protected virtual async Task ValidateNameAsync(string displayName, Guid?expectedId = null)
{
var edition = await EditionRepository.FindByDisplayNameAsync(displayName);
if (edition != null && edition.Id != expectedId)
{
throw new UserFriendlyException(Localizer["Edition.DuplicateName", displayName]);
}
}
public override async Task <PagedResultDto <EditionDto> > GetListAsync(GetEditionInput input)
{
var count = await EditionRepository.GetCountAsync(input.Filter);
var list = await EditionRepository.GetListAsync(input.Sorting, input.MaxResultCount, input.SkipCount, input.Filter);
return(new PagedResultDto <EditionDto>(
count,
ObjectMapper.Map <List <Edition>, List <EditionDto> >(list)));
}
public ServerImpl()
{
conferenceRepository = new ConferenceRepository();
editionRepository = new EditionRepository();
paperRepo = new PaperRepository();
bidRepo = new BidRepository();
userRepo = new UserRepository();
reviewRepo = new ReviewRepository();
reviewerRepo = new ReviewerRepository();
}
public async Task <EditionDto> UpdateAsync(Guid id, EditionUpdateDto input)
{
var edition = await EditionRepository.GetAsync(id);
await EditionManager.ChangeNameAsync(edition, input.DisplayName);
await EditionRepository.UpdateAsync(edition);
return(ObjectMapper.Map <Edition, EditionDto>(edition));
}
public async Task DeleteAsync(Guid id)
{
var edition = await EditionRepository.FindAsync(id);
if (edition == null)
{
return;
}
await EditionRepository.DeleteAsync(edition);
}
public UnitOfWork(IDatabaseContext databaseContext)
{
_context = databaseContext ?? throw new ArgumentNullException(nameof(databaseContext));
EventRepository = new EventRepository(_context);
EditionRepository = new EditionRepository(_context);
ActivityRepository = new ActivityRepository(_context);
ActivityStatusRepository = new ActivityStatusRepository(_context);
ActivityTypeRepository = new ActivityTypeRepository(_context);
TimeSlotRepository = new TimeSlotRepository(_context);
}
public async Task <EditionDto> GetAsync(Guid id)
{
return(ObjectMapper.Map <Edition, EditionDto>(
await EditionRepository.GetAsync(id)));
}
public virtual Task <Edition> GetByIdAsync(int id)
{
return(EditionRepository.GetAsync(id));
}
public virtual Task <Edition> FindByIdAsync(int id)
{
return(EditionRepository.FirstOrDefaultAsync(id));
}
public virtual Task <Edition> FindByNameAsync(string name)
{
return(EditionRepository.FirstOrDefaultAsync(edition => edition.Name == name));
}
public virtual Task CreateAsync(Edition edition)
{
return(EditionRepository.InsertAsync(edition));
}
public virtual Task DeleteAsync(Edition edition)
{
return(EditionRepository.DeleteAsync(edition));
}
public async Task <List <Edition> > GetAllAsync()
{
return(await EditionRepository.GetAllListAsync());
}
public virtual async Task <Edition> FindByDisplayNameAsync(string displayName)
{
return(await EditionRepository.FindByDisplayNameAsync(displayName));
}
