Exemple #1
0
 public async Task <LabelResponseModel> UpdateLabel(int userId, int labelId, LabelsRequestModel labelsRequestModel)
 {
     try
     {
         var        labelModel = _userContext.Labels.FirstOrDefault(linq => (linq.UserId == userId) && (linq.Id == labelId));
         LabelModel label      = new LabelModel();
         if (labelModel != null)
         {
             labelModel.Label = labelsRequestModel.Label;
             var data = this._userContext.Labels.Attach(labelModel);
             data.State = Microsoft.EntityFrameworkCore.EntityState.Modified;
             await this._userContext.SaveChangesAsync();
         }
         LabelResponseModel labelResponse = new LabelResponseModel()
         {
             Id         = label.Id,
             Label      = label.Label,
             IsCreated  = label.IsCreated,
             IsModified = label.IsModified
         };
         return(labelResponse);
     }
     catch (Exception e)
     {
         throw new Exception(e.Message);
     }
 }
        /// <summary>
        /// Create a New Label in the Database
        /// </summary>
        /// <param name="label">Label Data</param>
        /// <param name="userId">user Id</param>
        /// <returns>Label Responses</returns>
        public async Task <LabelResponseModel> CreateLabel(LabelRequest label, int userId)
        {
            try
            {
                if (label != null || !string.IsNullOrWhiteSpace(label.Name))
                {
                    var labelData = new LabelDetails
                    {
                        UserId     = userId,
                        Name       = label.Name,
                        CreatedAt  = DateTime.Now,
                        ModifiedAt = DateTime.Now
                    };

                    _applicationContext.LabelDetails.Add(labelData);
                    await _applicationContext.SaveChangesAsync();

                    var labelResponse = new LabelResponseModel
                    {
                        LabelId    = labelData.LabelId,
                        Name       = labelData.Name,
                        CreatedAt  = labelData.CreatedAt,
                        ModifiedAt = labelData.ModifiedAt
                    };

                    return(labelResponse);
                }
                return(null);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
Exemple #3
0
        public async Task <LabelResponseModel> AddLabel(LabelsRequestModel label, int userId)
        {
            try
            {
                LabelModel labelModel = new LabelModel
                {
                    UserId     = userId,
                    Label      = label.Label,
                    IsCreated  = DateTime.Now,
                    IsModified = DateTime.Now
                };
                LabelResponseModel labelResponse = new LabelResponseModel()
                {
                    Id         = labelModel.Id,
                    Label      = labelModel.Label,
                    IsCreated  = labelModel.IsCreated,
                    IsModified = labelModel.IsModified
                };
                _userContext.Labels.Add(labelModel);
                await _userContext.SaveChangesAsync();

                return(labelResponse);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
        /// <summary>
        /// Update the Label in the Database.
        /// </summary>
        /// <param name="updateLabel">Label Data</param>
        /// <param name="LabelId">Label Id</param>
        /// <returns>Update Label Data</returns>
        public async Task <LabelResponseModel> UpdateLabel(LabelRequest updateLabel, int LabelId)
        {
            try
            {
                LabelDetails labelDetails = _applicationContext.LabelDetails.FirstOrDefault(label => label.LabelId == LabelId);

                if (labelDetails != null)
                {
                    labelDetails.Name       = updateLabel.Name;
                    labelDetails.ModifiedAt = DateTime.Now;

                    var data = _applicationContext.LabelDetails.Attach(labelDetails);
                    data.State = Microsoft.EntityFrameworkCore.EntityState.Modified;
                    await _applicationContext.SaveChangesAsync();

                    var labelResponse = new LabelResponseModel
                    {
                        LabelId    = labelDetails.LabelId,
                        Name       = labelDetails.Name,
                        CreatedAt  = labelDetails.CreatedAt,
                        ModifiedAt = labelDetails.ModifiedAt
                    };

                    return(labelResponse);
                }
                return(null);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
Exemple #5
0
        public async Task <IActionResult> CreateLabel([FromBody] LabelRequest label)
        {
            try
            {
                var    user   = HttpContext.User;
                bool   status = false;
                string message;
                if (user.HasClaim(c => c.Type == _tokenType))
                {
                    if (user.Claims.FirstOrDefault(c => c.Type == _tokenType).Value == _login &&
                        user.Claims.FirstOrDefault(c => c.Type == _userType).Value == _regularUser)
                    {
                        int UserId = Convert.ToInt32(user.Claims.FirstOrDefault(c => c.Type == _userId).Value);
                        LabelResponseModel data = await _labelBusiness.CreateLabel(label, UserId);

                        if (data != null)
                        {
                            status  = true;
                            message = "Your Label Has been Successfully Created.";
                            return(Ok(new { status, message, data }));
                        }
                        message = "Unable to Create the Label.";
                        return(NotFound(new { status, message }));
                    }
                }
                message = "Invalid Token";
                return(BadRequest(new { status, message }));
            }
            catch (Exception e)
            {
                return(BadRequest(new { e.Message }));
            }
        }
        /// <summary>
        /// Adds the labels.
        /// </summary>
        /// <param name="requestedLabel">The requested label.</param>
        /// <param name="userid">The userid.</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public async Task <LabelResponseModel> AddLabels(RequestedLabel requestedLabel, int userid)
        {
            try
            {
                LabelModel label = new LabelModel
                {
                    LabelName  = requestedLabel.LabelName,
                    IsCreated  = DateTime.Now,
                    IsModified = DateTime.Now,
                    UserId     = userid
                };
                _userContext.label.Add(label);
                await _userContext.SaveChangesAsync();

                LabelResponseModel labelResponseModel = new LabelResponseModel()
                {
                    LabelID    = label.LabelID,
                    LabelName  = label.LabelName,
                    IsCreated  = label.IsCreated,
                    IsModified = label.IsModified
                };
                return(labelResponseModel);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
 /// <summary>
 /// Updates the labels.
 /// </summary>
 /// <param name="requestedLabel">The requested label.</param>
 /// <param name="userid">The userid.</param>
 /// <param name="labelid">The labelid.</param>
 /// <returns></returns>
 /// <exception cref="Exception"></exception>
 public async Task <LabelResponseModel> UpdateLabels(RequestedLabel requestedLabel, int userid, int labelid)
 {
     try
     {
         LabelModel labelModel = _userContext.label.FirstOrDefault(c => (c.UserId == userid) && (c.LabelID == labelid));
         if (labelModel != null)
         {
             labelModel.LabelName = requestedLabel.LabelName;
             var note = this._userContext.label.Attach(labelModel);
             note.State = Microsoft.EntityFrameworkCore.EntityState.Modified;
             await this._userContext.SaveChangesAsync();
         }
         LabelResponseModel labelResponseModel = new LabelResponseModel()
         {
             LabelID    = labelModel.LabelID,
             LabelName  = labelModel.LabelName,
             IsCreated  = labelModel.IsCreated,
             IsModified = labelModel.IsModified
         };
         return(labelResponseModel);
     }
     catch (Exception e)
     {
         throw new Exception(e.Message);
     }
 }
        public EtowerResponseModel CreateShipment(List <ETowerRequestModel> request, int DirectShipmentDraftId)
        {
            EtowerResponseModel response = new EtowerResponseModel();
            var    logisticIntegration   = UtilityRepository.getLogisticIntegration(UtilityRepository.GetOperationZone().OperationZoneId, AppSettings.ApplicationMode, FrayteIntegration.ETOWER);
            string url = logisticIntegration.ServiceUrl + "/services/shipper/orders";
            var    shipmentRequestjson = JsonConvert.SerializeObject(request);
            var    result = ETowerApiCalling(url, shipmentRequestjson, "Shipment");

            response          = Newtonsoft.Json.JsonConvert.DeserializeObject <EtowerResponseModel>(result);
            response.Request  = shipmentRequestjson;
            response.Response = result;
            if (response.status == "Success")
            {
                LabelResponseModel label = new LabelResponseModel();

                #region Label Dwonload

                var eTowerLableRequest = new EtowerLableRequest()
                {
                    labelFormat = "PDF",
                    labelType   = 1,
                    merged      = false,
                    packinglist = true,
                };
                eTowerLableRequest.orderIds = new List <string>();
                eTowerLableRequest.orderIds.Add(response.data[0].orderId);
                var    labeljson     = JsonConvert.SerializeObject(eTowerLableRequest);
                string Labelurl      = logisticIntegration.ServiceUrl + "/services/shipper/labels";
                var    lableResponse = ETowerApiCalling(Labelurl, labeljson, "Label");
                label = JsonConvert.DeserializeObject <LabelResponseModel>(lableResponse);

                if (label.status == "Success")
                {
                    response.data[0].labelContent = label.data[0].labelContent;
                }
                else
                {
                    //Label Error
                }

                #endregion
            }
            else
            {
                var EtowerError = JsonConvert.DeserializeObject <EtowerError>(result);
            }
            return(response);
        }