public void Setup()
{
_workDto = new WorkDto
{
Id = new Guid("184b7f06-a18c-42ef-b476-b42cfc7019b5"),
Title = "Lego House",
Type = "Song",
Disambiguation = ""
};
// If you ever want *real* data, there's some here:
//_recordingDtos = JsonConvert.DeserializeObject<IEnumerable<RecordingDto>>(TestResources.LegoHouseRecordings).ToArray();
_recordingDtos = new[]
{
new RecordingDto {
Length = 175000
},
new RecordingDto {
Length = 180000
},
new RecordingDto {
Length = 185000
}
};
}
public void Add(WorkDto work)
{
int max = Works.Keys.Count == 0 ? 1 : Works.Keys.Max(p => p) + 1;
work.WorkID = max;
Works.Add(max, work);
}
public void UpdateWork(WorkDto WorkDto)
{
var work = db.Works.Where(x => x.Id == WorkDto.Id).FirstOrDefault();
if (work.StatusWork == (WorkStatus)3)
{
//This update after rejected send email and change status to pinding
work.StatusWork = (WorkStatus)1;
}
work.Title = WorkDto.Title;
work.Description = WorkDto.Description;
work.Title = WorkDto.Title;
//open stream
Stream stream = WorkDto.TheFile.OpenReadStream();
//
using (BinaryReader Br = new BinaryReader(stream))
{
//convert file to array of byte .... Read byte
var ByteFile = Br.ReadBytes((int)stream.Length);
work.FileName = WorkDto.TheFile.FileName;
work.ContentType = WorkDto.TheFile.ContentType;
work.TheFile = ByteFile;
}
db.Works.Update(work);
db.SaveChanges();
}
public IHttpActionResult Put(int?id, [FromBody] WorkDto work)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id == null || id <= 0)
{
return(BadRequest());
}
var dbWork = workService.GetByID((int)id);
if (dbWork == null)
{
return(NotFound());
}
dbWork.ComposerID = work.ComposerID;
dbWork.Title = work.Title;
dbWork.EraID = work.EraID;
dbWork.Description = work.Description;
dbWork.Year = work.Year;
workService.Update(dbWork);
workService.Save();
return(StatusCode(HttpStatusCode.NoContent));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void RepositoryTest_Update_TaxIdUnique_Fail()
{
//Arrange
var dateTime = DateTime.Now;
WorkDto wDto = ((WorkDto)FakeDataFactory.GetDto <WorkDto>(
taxId: 2
));
var contactsDto = new List <ContactDto>()
{
FakeDataFactory.GetDto <WorkDto>(
taxId: 1
),
wDto
};
var repository = new ContactRepository(contactsDto);
var updatedContact = wDto.ToContact();
updatedContact.TaxId = 1;
//Act
var result = repository.Update(updatedContact, 2);
//Assert
Assert.AreEqual(result, false);
}
public void RepositoryTest_Update_TypeMisMatch_Fail()
{
//Arrange
var dateTime = DateTime.Now;
WorkDto wDto = ((WorkDto)FakeDataFactory.GetDto <WorkDto>(
taxId: 1,
name: "Name1",
address: "address11",
company: "Company1",
dateModified: dateTime,
emailAddress: "[email protected]",
phoneNumber: "000000001",
title: "Title1",
url: "www.url1.com"
));
var contactsDto = new List <ContactDto>()
{
wDto
};
var repository = new ContactRepository(contactsDto);
//Act
var result = repository.Update(FakeDataFactory.Get <FriendContact>(), 1);
//Assert
Assert.AreEqual(result, false);
}
public void MapperTest_ContactDtoToContact_Work()
{
//Arrange
//Act
WorkDto wDto = new WorkDto()
{
TaxId = 1,
Name = "Name",
DateCreated = new DateTime(),
DateModified = new DateTime(),
PhoneNumber = "999-999-9999",
Address = "Address",
Url = "www.url.com",
Title = "Title"
};
Contact cc = ((ContactDto)wDto).ToContact();
//Assert
Assert.AreEqual(cc.Name, wDto.Name);
Assert.AreEqual(cc.TaxId, wDto.TaxId);
Assert.AreEqual(cc.DateCreated, wDto.DateCreated);
Assert.AreEqual(cc.DateModified, wDto.DateModified);
Assert.AreEqual(((WorkContact)cc).Url, wDto.Url);
Assert.AreEqual(((WorkContact)cc).Title, wDto.Title);
Assert.AreEqual(cc.PhoneNumber, wDto.PhoneNumber);
Assert.AreEqual(cc.Address, wDto.Address);
}
public void RepositoryTest_GetByName()
{
//Arrange
WorkDto wc = new WorkDto()
{
TaxId = 1,
Name = "Name",
Address = "address1",
Company = "Company",
EmailAddress = "*****@*****.**",
PhoneNumber = "000000000",
Title = "Title",
Url = "www.url.com"
};
var contactsDto = new List <ContactDto>()
{
wc
};
var repository = new ContactRepository(contactsDto);
//Act
Contact result = repository.Get("Name");
//Assert
Assert.IsInstanceOfType(result, typeof(WorkContact));
Assert.AreEqual(result.Address, wc.Address);
Assert.AreEqual(result.DateCreated, wc.DateCreated);
Assert.AreEqual(result.DateModified, wc.DateModified);
Assert.AreEqual(result.Name, wc.Name);
Assert.AreEqual(result.PhoneNumber, wc.PhoneNumber);
Assert.AreEqual(result.TaxId, wc.TaxId);
Assert.AreEqual(((WorkContact)result).Title, wc.Title);
Assert.AreEqual(((WorkContact)result).Url, wc.Url);
}
public IHttpActionResult Post([FromBody] WorkCreateDto work)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Work newWork = new Work
{
ComposerID = work.ComposerId,
Title = work.Title,
EraID = work.EraId,
Description = work.Description,
Year = work.Year
};
workService.Add(newWork);
workService.Save();
var dtoWork = new WorkDto(newWork);
return(Ok(dtoWork));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void MapperTest_WorkDtoToWorkContact()
{
//Arrange
//Act
WorkDto wc = new WorkDto()
{
TaxId = 1,
Name = "Name",
DateCreated = new DateTime(),
DateModified = new DateTime(),
Url = "www.url.com",
EmailAddress = "*****@*****.**",
Title = "Title",
PhoneNumber = "999-999-9999",
Address = "Address"
};
WorkContact wDto = wc.ToWorkContact();
//Assert
Assert.AreEqual(wDto.Name, wc.Name);
Assert.AreEqual(wDto.TaxId, wc.TaxId);
Assert.AreEqual(wDto.DateCreated, wc.DateCreated);
Assert.AreEqual(wDto.DateModified, wc.DateModified);
Assert.AreEqual(wDto.EmailAddress, wc.EmailAddress);
Assert.AreEqual(wDto.Url, wc.Url);
Assert.AreEqual(wDto.Title, wc.Title);
Assert.AreEqual(wDto.PhoneNumber, wc.PhoneNumber);
Assert.AreEqual(wDto.Address, wc.Address);
}
public async Task <ActionResult <Work> > CreateWork(WorkDto workDto)
{
var userId = User.GetUserId();
var user = await _unitOfWork.UserRepository.GetUserByIdAsync(userId);
var offer = await _unitOfWork.OfferRepository.GetOfferByIdAsync(workDto.OfferId);
if (offer == null)
{
return(NotFound("There is no offer"));
}
var workToAdd = _mapper.Map <Work>(workDto);
workToAdd.UserId = userId;
workToAdd.WorkStatusName = WorkStatus.Pending;
_unitOfWork.WorkRepository.Add(workToAdd);
if (await _unitOfWork.SaveAll())
{
return(CreatedAtRoute("works", new { workId = workToAdd.Id, offerId = offer.Id }, workToAdd));
}
return(BadRequest("Saving work didn't succeed"));
}
public void Update(WorkDto work)
{
if (Works.ContainsKey(work.WorkID))
{
Works[work.WorkID] = work;
}
}
public void InsertWork(WorkDto WorkDto, String DeveloperId)
{
var NewWork = new Work()
{
Title = WorkDto.Title,
Description = WorkDto.Description,
DeveloperId = DeveloperId,
SprintTaskId = WorkDto.SprintTaskId,
};
NewWork.StatusWork = (WorkStatus)WorkDto.StatusWorkDto;
//open stream
Stream stream = WorkDto.TheFile.OpenReadStream();
//
using (BinaryReader Br = new BinaryReader(stream))
{
//convert file to array of byte .... Read byte
var ByteFile = Br.ReadBytes((int)stream.Length);
NewWork.FileName = WorkDto.TheFile.FileName;
NewWork.ContentType = WorkDto.TheFile.ContentType;
NewWork.TheFile = ByteFile;
}
db.Works.Add(NewWork);
db.SaveChanges();
}
public async Task <object> GetWorkList([FromBody] WorkDto query)
{
var context = HttpContext;
string account = await _jwtUtil.GetMessageByToken(context);
query.CompId = _commonAppService.GetUserCompId(account);
return(_dangAnAppService.GetWorkList(query));
}
private void btnSave_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(tbTitle.Text))
{
MessageBox.Show("Название работы не может быть пустым!");
return;
}
if (string.IsNullOrEmpty(tbCopy.Text))
{
MessageBox.Show("Укажите копию работы!");
return;
}
if (string.IsNullOrEmpty(cbArtist.Text))
{
MessageBox.Show("Укажите автора работы!");
return;
}
if (string.IsNullOrEmpty(dpAcuired.Text))
{
MessageBox.Show("Укажите дату приобретения работы!");
return;
}
if (string.IsNullOrEmpty(tbAcquisitionPrice.Text))
{
MessageBox.Show("Укажите цену приобретения работы!");
return;
}
WorkDto work = new WorkDto
{
Title = tbTitle.Text,
Copy = tbCopy.Text,
Description = tbDescription.Text,
Artist = (ArtistDto)this.cbArtist.SelectedItem
};
TransactionDto transaction = new TransactionDto
{
AcquisitionPrice = Convert.ToDecimal(tbAcquisitionPrice.Text),
DateAcquired = Convert.ToDateTime(this.dpAcuired.Text)
};
IWorkProcess workProcess = ProcessFactory.GetWorkProcess();
ITransactionProcess transProcess = ProcessFactory.GetTransactionProcess();
if (_id == 0)
{
workProcess.Add(work);
FreeForSale = ProcessFactory.GetWorkProcess().GetList();
transaction.Work = FreeForSale.Last();
transProcess.Add(transaction);
}
else
{
work.Id = _id;
workProcess.Update(work);
}
this.Close();
}
public async Task <ActionResult> Edit(WorkDto worksDto)
{
if (!ModelState.IsValid)
{
return(View(worksDto));
}
await _customerService.Update(worksDto);
return(RedirectToAction("Index", "Customer"));
}
public WorkViewModel(WorkDto work)
{
Id = work.Id;
Title = work.Title;
Type = work.Type;
Disambiguation = work.Disambiguation;
Relationships = work.Relationships?.Select(x => new RelationshipViewModel(x)) ??
Enumerable.Empty <RelationshipViewModel>();
}
private void cbWork_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (this.status == "sale")
{
WorkDto work = cbWork.SelectedItem as WorkDto;
if (work != null)
{
this._transactionid = FindTransaction(work.WorkID);
}
loadTransaction(this._transactionid);
}
}
public async Task GetLyrics_WhenNoTitleProvided_ReturnNull()
{
// Arrange
var caller = GetLyricsOvhCaller();
var artist = new ArtistDto {Name = TestResources.ExampleArtistName};
var work = new WorkDto {Title = string.Empty};
// Act
var result = await caller.GetLyrics(artist.Name, work.Title);
// Assert
Assert.That(result == null);
}
public async Task GetLyrics_ArtistAndTitleProvided_ReturnLyricsDto()
{
// Arrange
var lyricsOvCaller = GetLyricsOvhCaller();
var artist = new ArtistDto {Name = TestResources.ExampleArtistName};
var work = new WorkDto {Title = TestResources.ExampleSongTitle};
// Act
var result = await lyricsOvCaller.GetLyrics(artist.Name, work.Title);
// Assert
Assert.That(result != null && result.Lyrics.Length > 0);
}
private WorkDto selectWork()
{
WorkDto work = null;
foreach (WorkDto w in Works)
{
if (w.Copy == this.cbCopy.Text && w.Title == this.cbWork.Text)
{
work = w; break;
}
}
return(work);
}
public void CalculateAddedCost(WorkDto work)
{
if (!work.NewPlannedStartDate.HasValue)
{
work.AddedCost = 0;
return;
}
var daysDifference = work.NewPlannedStartDate.Value.Subtract(work.PlannedStartDate).Days;
work.AddedCost = daysDifference > 0
? work.IncDayCost * daysDifference
: work.DecDayCost * daysDifference;
}
private void btnEditW_Click(object sender, RoutedEventArgs e)
{
WorkDto item = dgWork.SelectedItem as WorkDto;
if (item == null)
{
MessageBox.Show("Выберите запись для редактирования", "Редактирование");
return;
}
AddWorkWindow window = new AddWorkWindow();
window.Load(item);
window.ShowDialog();
}
public async Task Add(WorkDto worksDto)
{
try
{
var entity = _mapper.Map <Works>(worksDto);
_databaseContex.Works.Add(entity);
await _databaseContex.SaveChangesAsync();
await _distributedCache.RemoveAsync("servicerecords");
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
public async Task <ActionResult> Add(WorkDto worksDto)
{
ViewBag.Categories = await _customerService.GetCategories();
if (!ModelState.IsValid)
{
return(View(worksDto));
}
var user = JsonConvert.DeserializeObject <ClaimDto>(User.Claims.Where(x => x.Type == ClaimTypes.Name).Select(x => x.Value).FirstOrDefault());
worksDto.UserId = user.Id;
await _customerService.Add(worksDto);
return(RedirectToAction("Index", "Customer"));
}
//
// WORK
//
public static WorkDto Convert(Work work)
{
if (work == null)
{
return(null);
}
WorkDto workDto = new WorkDto();
workDto.WorkID = work.WorkID;
workDto.Artist = Convert(DaoFactory.GetArtistDao().Get(work.ArtistID));
workDto.Title = work.Title;
workDto.Copy = work.Copy;
workDto.Description = work.Description;
return(workDto);
}
public static Work Convert(WorkDto workDto)
{
if (workDto == null)
{
return(null);
}
Work work = new Work();
work.WorkID = workDto.WorkID;
work.ArtistID = workDto.Artist.Id;
work.Title = workDto.Title;
work.Copy = workDto.Copy;
work.Description = workDto.Description;
return(work);
}
public IHttpActionResult Get(string title)
{
if (string.IsNullOrEmpty(title))
{
return(BadRequest());
}
var work = workService.GetWorkByTitle(title);
if (work == null)
{
return(NotFound());
}
var dtoWork = new WorkDto(work);
return(Ok(dtoWork));
}
public IHttpActionResult Get(int?id)
{
if (id == null || id <= 0)
{
return(BadRequest());
}
var work = workService.GetByID((int)id);
if (work == null)
{
return(NotFound());
}
var dtoWork = new WorkDto(work);
return(Ok(dtoWork));
}
public async Task Update(WorkDto worksDto)
{
try
{
var entity = _mapper.Map <Works>(worksDto);
var entry = _databaseContex.Entry(entity);
entry.State = EntityState.Modified;
await _databaseContex.SaveChangesAsync();
await _distributedCache.RemoveAsync("servicerecords");
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
