public void Put_Existing_Widget_NotFound()
{
var options = new DbContextOptionsBuilder <WidgetContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using (var context = new WidgetContext(options))
{
context.Widgets.Add(new Widget {
Id = id1, Name = GetRandomString(), Shape = GetRandomString()
});
context.Widgets.Add(new Widget {
Id = id2, Name = GetRandomString(), Shape = GetRandomString()
});
context.Widgets.Add(new Widget {
Id = id3, Name = GetRandomString(), Shape = GetRandomString()
});
context.SaveChanges();
var widgetDTO = new WidgetDTO {
Id = Guid.NewGuid(), Name = GetRandomString(), NumberOfGears = 42
};
var controller = new WidgetController(context);
var actionResult = controller.Put(widgetDTO).Result;
var result = actionResult as NotFoundResult;
Assert.IsNotNull(result);
Assert.AreEqual(404, result.StatusCode);
}
}
public async Task <ActionResult> UploadWidget([FromForm] WidgetDTO newWidget)
{
if (ModelState.IsValid)
{
try
{
if (!Directory.Exists(contentFolderPath))
{
Directory.CreateDirectory(contentFolderPath);
}
using (var stream = new FileStream(contentFolderPath, FileMode.Create))
{
await newWidget.FeatureImage.CopyToAsync(stream);
newWidget.WidgetResources = new WidgetResourcesDTO();
newWidget.WidgetResources.FeatureIamagePath = $"{contentFolderPath}\\{newWidget.FeatureImage.FileName}";
}
await _widgetServices.UploadWidget(newWidget);
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e));
}
}
return(BadRequest("Not valid"));
}
public async Task <IActionResult> Put(string id, [FromBody] WidgetDTO widgetDTO)
{
AuthController.ValidateAndGetCurrentUserName(this.HttpContext.Request);
Widget widget = context.Widgets.Find(Guid.Parse(id));
if (widget == null)
{
return(NotFound());
}
Widget oldwgt = await context.Widgets.FirstOrDefaultAsync(w => w.UserID == widgetDTO.Email &&
w.WidgetName == widgetDTO.WidgetName &&
w.ID.ToString() != widgetDTO.ID.ToString()
);
if (oldwgt != null)
{
return(BadRequest("DuplicateName"));
}
widget.updateFromWidgetDTO(widgetDTO);
await context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> UpdateExtension(string id, [FromBody] WidgetDTO widgetDTO)
{
AuthController.ValidateAndGetCurrentUserName(this.HttpContext.Request);
Widget widget = await context.Widgets
.Include(e => e.User)
.FirstOrDefaultAsync(e => e.ID.ToString() == id);
if (widget == null)
{
return(NotFound());
}
widget.AuthKey = widgetDTO.AuthKey;
widget.Extension = widgetDTO.Extension;
try{
EmailManager.SendActivationWidgetNotification(widget);
}
catch (Exception)
{
}
await context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> UpdateAsync(WidgetDTO widgetDTO, int Id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessage()));
}
else
{
IDataResult <Widget> dataResult = await _iWidgetService.FindByIdAsync(Id);
if (dataResult.Data == null)
{
return(BadRequest(dataResult.Message));
}
_iMapper = WidgetMapping.GetMapper().CreateMapper();
Widget widget = _iMapper.Map <WidgetDTO, Widget>(widgetDTO);
IResult result = await _iWidgetService.UpdateAsync(widget);
if (result.Success)
{
return(Ok(result.Message));
}
return(BadRequest(result.Message));
}
}
public async Task UploadWidget(WidgetDTO newWidget)
{
var widget = new Widgets();
_mapper.Map(newWidget, widget);
await _repository.AddAsync(widget);
}
public IActionResult Update(WidgetDTO widgetDTO, int Id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessage()));
}
else
{
IDataResult <Widget> result = _iWidgetService.GetById(Id);
if (result == null)
{
return(BadRequest(result.Message));
}
else
{
_iMapper = WidgetMapping.GetMapper().CreateMapper();
Widget widget = _iMapper.Map <WidgetDTO, Widget>(widgetDTO);
IResult updateResult = _iWidgetService.Update(widget);
if (updateResult.Success)
{
return(Ok(updateResult.Message));
}
return(BadRequest(updateResult.Message));
}
}
}
public async Task <ActionResult <WidgetDTO> > UpdateWidget(long id, WidgetDTO widgetDTO)
{
try
{
// Logging added
_logger.LogInformation("PUT: widget/{0}", id);
// Validate PUT request early before calling conte
if (id != widgetDTO.Id)
{
return(BadRequest());
}
var responseWidgetDTO = await _context.Update(widgetDTO);
return(Ok());
}
catch (System.Exception e)
{
// Logging added
_logger.LogError(e, "UnprocessableEntity");
return(UnprocessableEntity());
}
}
public async Task <IActionResult> Post([FromBody] WidgetDTO widget)
{
AuthController.ValidateAndGetCurrentUserName(this.HttpContext.Request);
if (widget == null)
{
return(NotFound());
}
string email = widget.Email;
try
{
Widget oldwgt = await context.Widgets.FirstOrDefaultAsync(w => w.UserID == email &&
w.WidgetName == widget.WidgetName);
if (oldwgt != null)
{
return(BadRequest("DuplicateName"));
}
Widget wgt = new Widget(widget, context);
context.Widgets.Add(wgt);
await context.SaveChangesAsync();
EmailManager.SendCreationWidgetNotification(wgt);
return(Ok(new { Token = wgt.ID }));
}catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> Disable(string id, [FromBody] WidgetDTO widgetDTO)
{
AuthController.ValidateAndGetCurrentUserName(this.HttpContext.Request);
Widget widget = context.Widgets.Find(Guid.Parse(id));
if (widget == null)
{
return(NotFound());
}
widget.Status = widgetDTO.Status;
await context.SaveChangesAsync();
return(Ok());
}
public async Task <WidgetDTO> Update(WidgetDTO widgetDTO)
{
var widget = await this.Widgets.FindAsync(widgetDTO.Id);
if (widget == null)
{
// Custom Exceptions added
throw new WidgetNotFoundException(
String.Format("Widget {0} Not Found", widgetDTO.Id)
);
}
widget.Date = widgetDTO.Date;
await this.SaveChangesAsync();
return(new WidgetDTO(widget));
}
public async Task <ActionResult <WidgetDTO> > CreateWidget(WidgetDTO widgetDTO)
{
try
{
// Logging added
_logger.LogInformation("POST: widget/{0}", widgetDTO.Id);
var responseWidgetDTO = await _context.Create(widgetDTO);
return(Ok());
}
catch (System.Exception e)
{
// Logging added
_logger.LogError(e, "UnprocessableEntity");
return(UnprocessableEntity());
}
}
public void updateFromWidgetDTO(WidgetDTO widget)
{
WidgetName = widget.WidgetName;
Status = widget.Status;
TalkToUsText = widget.TalkToUsText;
ColorWidget = widget.ColorWidget;
ColorText = widget.ColorText;
IsAnimated = widget.IsAnimated;
DomainURL = widget.DomainUrl;
AuthKey = widget.AuthKey;
Extension = widget.Extension;
NotificationEmail = widget.NotificationEmail;
WeekDays = WeekDay.ConvertToString(widget.WeekDays);
subscriptionId = widget.subscriptionId;
}
public IActionResult Add(WidgetDTO widgetDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessage()));
}
else
{
_iMapper = WidgetMapping.GetMapper().CreateMapper();
Widget widget = _iMapper.Map <WidgetDTO, Widget>(widgetDTO);
IResult result = _iWidgetService.Add(widget);
if (result.Success)
{
return(Ok(result.Message));
}
return(BadRequest(result.Message));
}
}
public Widget(WidgetDTO widgetDTO, MyDBContext context)
{
ID = Guid.NewGuid();
UserID = widgetDTO.Email;
this.User = context.Users.Find(UserID);
DomainURL = widgetDTO.DomainUrl;
WidgetName = widgetDTO.WidgetName;
ConnectedTo = widgetDTO.ConnectedTo;
Status = widgetDTO.Status;
TalkToUsText = widgetDTO.TalkToUsText;
ColorWidget = widgetDTO.ColorWidget;
ColorText = widgetDTO.ColorText;
IsAnimated = widgetDTO.IsAnimated;
CallsCount = 0;
CallsCountMonth = 0;
CreationDateTime = DateTime.Now;
NotificationEmail = widgetDTO.NotificationEmail;
WeekDays = WeekDay.ConvertToString(widgetDTO.WeekDays);
subscriptionId = widgetDTO.subscriptionId;
}
public async Task <IActionResult> AddAsync(WidgetDTO widgetDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessage()));
}
else
{
_iMapper = WidgetMapping.GetMapper().CreateMapper();
Widget widget = _iMapper.Map <WidgetDTO, Widget>(widgetDTO);
IResult result = await _iWidgetService.AddAsync(widget);
if (result.Success)
{
return(Ok(result.Message));
}
return(BadRequest($"{result.Message} \n Try Again later can be either server error or user error "));
}
}
static void Main(string[] args)
{
Widget w = new Widget();
try
{
w.Id = 1;
w.Display("w");
WidgetDTO wd = new WidgetDTO();
wd.Id = 2;
wd.Display("wd");
throw new WidgetNotImplentedException(
String.Format("Error in Widget {0}", wd.Id));
}
catch (WidgetNotImplentedException e)
{
Console.WriteLine(e.Display());
Console.WriteLine(w.Display("Widget In Error"));
}
}
public async Task <IActionResult> Post([FromBody] WidgetDTO widgetDTO)
{
if (widgetDTO == null)
{
throw new ArgumentNullException(nameof(widgetDTO));
}
var item = await _context.Widgets
.FirstOrDefaultAsync(w => w.Id == widgetDTO.Id)
.ConfigureAwait(false);
if (item != null)
{
return(Conflict()); // 409
}
_context.Widgets.Add(widgetDTO.ToWidget());
await _context.SaveChangesAsync().ConfigureAwait(false);
return(NoContent()); // 204
}
public async Task <IActionResult> Put([FromBody] WidgetDTO widgetDTO)
{
if (widgetDTO == null)
{
throw new ArgumentNullException(nameof(widgetDTO));
}
var item = await _context.Widgets
.FirstOrDefaultAsync(w => w.Id == widgetDTO.Id)
.ConfigureAwait(false);
if (item == null)
{
return(NotFound());
}
item.Name = widgetDTO.Name;
item.Shape = widgetDTO.Shape;
await _context.SaveChangesAsync().ConfigureAwait(false);
return(NoContent()); // 204
}
public async Task <IEnumerable <WidgetDTO> > GetAllWidgetsForUser(string email)
{
try
{
AuthController.ValidateAndGetCurrentUserName(this.HttpContext.Request);
email = email.Replace("'", "");
List <Widget> widgetList = new List <Widget>();
widgetList = await context.Widgets.Include(widget => widget.User)
.Where(widget => widget.UserID == email)
.OrderBy(widget => widget.CreationDateTime)
.ToListAsync();
List <WidgetDTO> widgetDTOList = new List <WidgetDTO>();
foreach (Widget widget in widgetList)
{
WidgetDTO wgtDTO = new WidgetDTO(widget);
if (CallmeController.IsWidgetOutofSubscription(widget, context))
{
wgtDTO.Status = "Out of Subscription";
}
else if (await CallmeController.IsWidgetOutofCallAsync(widget, context))
{
wgtDTO.Status = "Out of Call";
}
widgetDTOList.Add(wgtDTO);
}
return(widgetDTOList);
}catch (Exception ex)
{
throw ex;
}
}
public async Task <WidgetDTO> Create(WidgetDTO widgetDTO)
{
var widget = await this.Widgets.FindAsync(widgetDTO.Id);
if (widget != null)
{
// Custom Exceptions added
throw new WidgetAlreadyExistsException(
String.Format("Widget {0} Already exists", widgetDTO.Id)
);
}
widget = new Widget
{
Id = widgetDTO.Id,
Date = widgetDTO.Date,
Secret = string.Empty
};
this.Widgets.Add(widget);
await this.SaveChangesAsync();
return(widgetDTO);
}
public bool AddUpdateWidget([FromBody] WidgetDTO dto)
{
return(_dataAPI.AddUpdateWidget(dto));
}
public async Task <ValidateResponse> GetScheduleAsync([FromBody] TokenDTO token)
{
try
{
DateTime now = DateTime.Parse(GetUKDateTime());
string dayOfWeek = GetDayofWeek();
if (token == null)
{
return new ValidateResponse {
result = "NotFound"
}
}
;
Widget wgt = context.Widgets.Include(widget => widget.User)
.Where(widget => widget.ID == Guid.Parse(token.token))
.FirstOrDefault();
if (wgt == null)
{
return new ValidateResponse {
result = "NotFound"
}
}
;
if (wgt.Status != "Active")
{
return new ValidateResponse {
result = "NotActive"
}
}
;
WidgetDTO wgtDTO = new WidgetDTO(wgt);
bool isOpen = false;
string startTime = "";
string endTime = "";
foreach (WeekDay day in wgtDTO.WeekDays)
{
if (day.name == dayOfWeek)
{
isOpen = day.isOpen;
startTime = day.startTime;
endTime = day.endTime;
}
}
ValidateResponse response = new ValidateResponse();
if (!isOpen)
{
response.result = DAYCLOSED;
response.datetimes = BuildSchedule(now, false, wgtDTO.WeekDays);
return(response);
}
string[] startTimeSplit = startTime.Split(":. ".ToCharArray());
int startTimeHour = int.Parse(startTimeSplit[0], System.Globalization.NumberStyles.Any);
int startTimeMin = int.Parse(startTimeSplit[1], System.Globalization.NumberStyles.Any);
string[] endTimeSplit = endTime.Split(":.".ToCharArray());
int endTimeHour = int.Parse(endTimeSplit[0], System.Globalization.NumberStyles.Any);
int endTimeMin = int.Parse(endTimeSplit[1], System.Globalization.NumberStyles.Any);
int nowHour = now.TimeOfDay.Hours;
int nowMin = now.TimeOfDay.Minutes;
if (nowHour < startTimeHour)
{
response.result = DAYCLOSED;
response.datetimes = BuildSchedule(now, true, wgtDTO.WeekDays);
return(response);
}
if (nowHour > endTimeHour)
{
response.result = DAYCLOSED;
response.datetimes = BuildSchedule(now, false, wgtDTO.WeekDays);
return(response);
}
if (nowHour == startTimeHour && nowMin < startTimeMin)
{
response.result = DAYCLOSED;
response.datetimes = BuildSchedule(now, true, wgtDTO.WeekDays);
return(response);
}
if (nowHour == endTimeHour && nowMin > endTimeMin)
{
response.result = DAYCLOSED;
response.datetimes = BuildSchedule(now, false, wgtDTO.WeekDays);
return(response);
}
response.result = DAYOPEN;
return(response);
}
catch (Exception ex)
{
AppException exception = new AppException();
exception.ErrorDateTime = DateTime.Now;
exception.Message = ex.Message;
exception.FullString = ex.ToString();
context.AppExceptions.Add(exception);
await context.SaveChangesAsync();
throw ex;
}
//List<CustomDateTime> datetimes = new List<CustomDateTime>();
//datetimes.Add(new CustomDateTime
//{
// date = "Oct 20",
// fulldate = "October 20, 2018",
// today = "y",
// day = "Thu",
// fullday = "Thursday",
// times = new string[] { "12:00", "12:30", "13:00", "13:30" }
//});
//datetimes.Add(new CustomDateTime
//{
// date = "Sep 10",
// fulldate = "September 10, 2018",
// today = "n",
// day = "Fri",
// fullday = "Friday",
// times = new string[] { "09:00", "09:30", "10:00", "10:30" }
//});
//datetimes.Add(new CustomDateTime
//{
// date = "Sep 14",
// fulldate = "September 14, 2018",
// today = "n",
// day = "Wed",
// fullday = "Wednesday",
// times = new string[] { "09:30", "10:30", "11:00", "11:30" }
//});
//response.datetimes = datetimes;
//return response;
}
