Merge branch 'RMSv2' of http://42.61.118.105:7990/scm/rms/api-main-service into gladys-dev2

app/applicationlayer/management/account/serializer.py

 from rest_framework import serializers
 from app.entities.models import User
 import ast
+from django.contrib.auth.hashers import make_password, check_password
+import re
 
 
 class UserSerializer(serializers.ModelSerializer):
     class Meta:
         model = User
-        fields = '__all__'
+        fields = (
+            'id',
+            'code', 'name',
+            'username', 'contact_no',
+            'department',
+            'email', 'default_app',
+            'user_type', 'is_active',
+            'doa',
+            # 'password',
+
+        )
         read_only_fields = (
             'created', 'createdby', 'modified', 'modifiedby', 'code',
         )
+
+
+class ChangePasswordSerializer(serializers.Serializer):
+    old_password = serializers.CharField(required=True)
+    new_password = serializers.CharField(required=True, min_length=6)
+
+    def validate(self, data):
+        instance = self.context.get("instance")
+        old_password = data['old_password']
+        new_password = data['new_password']
+        instance_password = User.objects.filter(
+            id=instance
+        )
+        validated_password = check_password(
+            old_password,
+            instance_password.values().first()['password']
+        )
+
+        if validated_password:
+            password = re.match(
+                '([A-Za-z]+[0-9]|[0-9]+[A-Za-z])[A-Za-z0-9]*',
+                data['new_password']
+            )
+            if password:
+                new_password = make_password(data['new_password'])
+                instance_password.update(password=new_password)
+                instance = User.objects.get(id=instance)
+                return instance
+            elif len(new_password) <= 5:
+                raise serializers.ValidationError(
+                    'Password must be minimum of 6 characters'
+                )
+            else:
+                raise serializers.ValidationError(
+                    'password must be alpha numeric format'
+                )
+        else:
+            raise serializers.ValidationError('Please ensure the old password is correct and both new password & confirm password are the same.')

app/applicationlayer/management/account/views.py

+import copy
 from app.entities import enums
 from django.db import transaction
 from app.helper.decorators import rms, error_safe
@@ -14,6 +15,11 @@ from app.applicationlayer.utils import (
 from django_filters.rest_framework import DjangoFilterBackend
 from app.applicationlayer.management.account import serializer
 from app.applicationlayer.management.account.table_filters import UserFilterSet
+from rest_framework.decorators import action
+from app.helper import decorators
+from django.contrib.auth import authenticate
+from app.helper.email_service import sender
+import threading
 
 
 class UserViewSet(viewsets.ModelViewSet):
@@ -29,17 +35,21 @@ class UserViewSet(viewsets.ModelViewSet):
     @rms.user_create
     @transaction.atomic
     def create(self, request, *args, **kwargs):
-        password = make_password(request.data['password'])
-        request.data['password'] = password
-        
         serializer = self.get_serializer(data=request.data)
         serializer.is_valid(raise_exception=True)
         self.perform_create(serializer)
-
+        password = User.objects.make_random_password(length=10)
+        password_hash = make_password(password)
+        User.objects.filter(
+            id=serializer.data['id']
+        ).update(password=password_hash)
         message = status_message_response(
             201, 'success',
             'New Users created', serializer.data
         )
+        args = [request.data['name'], request.data['username'], password, request.user.email]
+        t1 = threading.Thread(target=sender.account_created, args=(args,))
+        t1.start()
 
         return Response(
             message
@@ -103,3 +113,106 @@ class UserViewSet(viewsets.ModelViewSet):
         )
 
         return Response(serializer.data)
+
+
+    # @action(detail=True,
+    #         methods=['put'],
+    #         url_path='upload-profile-picture',
+    #         name="Uploads Profile Picture of User")
+    # @decorators.error_safe
+    # @transaction.atomic
+    # def UploadProfilePicture(self, request, pk=None):
+    #     existingUser = models.User.objects.filter(id=pk).first()
+    #     if existingUser:
+
+    #         eximages = models.UserImage.objects.filter(user_id=pk)
+
+    #         if (eximages):
+    #             for item in eximages:
+    #                 item.delete()
+    #                 # DELETE FROM PHYSICAL
+    #                 FileHelper.DeleteFile(path=item.image.path)
+
+    #         self.serializer_class = app_serializers.UserImageSerializer
+
+    #         serializer = self.get_serializer(data=request.data)
+    #         serializer.is_valid(raise_exception=True)
+    #         self.perform_create(serializer)
+    #         headers = self.get_success_headers(serializer.data)
+
+    #         return Response(serializer.data,
+    #                         status=status.HTTP_201_CREATED,
+    #                         headers=headers)
+    #     else:
+    #         raise Exception('User not found')
+    #     return Response(data={"detail": "Success"})
+
+    # @action(detail=True,
+    #         methods=['put'],
+    #         url_path='reset-password',
+    #         name="Reset Password of User")
+    # @decorators.error_safe
+    # @transaction.atomic
+    # def ResetPassword(self, request, pk=None):
+    #     existingUser = models.User.objects.filter(id=pk).first()
+    #     if existingUser:
+    #         existingUser.set_password(settings.USER_DEFAULT_PASSWORD)
+
+    #         fromObj = copy.copy(existingUser)
+    #         existingUser.save()
+    #         toObj = copy.copy(existingUser)
+    #         log_save.log_save(
+    #             enums.LogEnum.UPDATE.value,
+    #             enums.LogEntitiesEnum.ROBOT.value,
+    #             model_to_dict(fromObj),
+    #             model_to_dict(toObj))
+    #     else:
+    #         raise Exception('User not found')
+    #     return Response(data={"detail": "Success"})
+
+    @action(detail=True,
+            methods=['put'],
+            url_path='change-password',
+            name="Change Password of User")
+    @decorators.error_safe
+    @transaction.atomic
+    def ChangePassword(self, request, pk=None):
+        self.serializer_class = serializer.ChangePasswordSerializer
+
+        data = self.get_serializer(data=request.data)
+        if data.is_valid():
+
+            form = copy.deepcopy(data.validated_data)
+
+            if form['new_password'] != form['new_password_confirm']:
+                raise Exception('Passwords must match')
+
+            existingUser = User.objects.filter(id=pk).first()
+            if existingUser:
+                user = authenticate(
+                    username=existingUser.username,
+                    password=form['old_password'])
+                if user:
+                    existingUser.set_password(form['new_password_confirm'])
+                    # password = make_password(request.data['password'])
+
+                    fromObj = copy.copy(existingUser)
+                    existingUser.save()
+                    toObj = copy.copy(existingUser)
+
+                    # log_save.log_save(
+                    #     enums.LogEnum.UPDATE.value,
+                    #     enums.LogEntitiesEnum.ROBOT.value,
+                    #     model_to_dict(fromObj),
+                    #     model_to_dict(toObj))
+
+                    return Response(data={"detail": "Success"},
+                                    status=200)
+                else:
+                    raise Exception("Invalid Old Password")
+            else:
+                raise Exception('User not found')
+        else:
+            serializer.is_valid(raise_exception=True)
+
+        return Response(data={"detail": "Error"}, status=500)

app/applicationlayer/management/department/serializer.py

 from rest_framework import serializers
-from app.entities.models import Department
+from app.entities.models import Department, Company
 
 
 class DepartmentSerializer(serializers.ModelSerializer):
+    def to_representation(self, instance):
+        company_name = Company.objects.filter(
+            id=instance.company.id
+        ).values().first()
+        ret = super().to_representation(instance)
+        ret['company'] = company_name
+        # ret['application'] = application_name
+
+        return ret
+        
     class Meta:
         model = Department
         fields = '__all__'

app/applicationlayer/management/module/serializer.py

 from rest_framework import serializers
-from app.entities.models import Module
+from app.entities.models import Module, Application
+# from app.applicationlayer.management.application import ApplicationSerializer
 
 
 class ModuleSerializer(serializers.ModelSerializer):
+    def to_representation(self, instance):
+        application_name = Application.objects.filter(
+            id=instance.application.id
+        ).values().first()
+        ret = super().to_representation(instance)
+        ret['application'] = application_name
+        # ret['application'] = application_name
+
+        return ret
+
     class Meta:
         model = Module
         fields = '__all__'

app/entities/migrations/0004_auto_20190910_1610.py

+# Generated by Django 2.2 on 2019-09-10 16:10
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('entities', '0003_auto_20190910_0956'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='module',
+            name='parent',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

app/entities/models.py

@@ -57,7 +57,7 @@ class Module(AuditClass):
         blank=True,
         null=True
     )
-    parent = models.IntegerField()
+    parent = models.IntegerField(blank=True, null=True)
     sort_id = models.IntegerField()
     component = models.CharField(
         max_length=255,
@@ -909,3 +909,9 @@ class Notification(models.Model):
         code = number_generator(enums.GenerateCode.NOTIFICATION.value, self.id)
         Notification.objects.filter(id=self.id).update(code=code)
 
+
+
+# class EmailLogs(AuditClass):
+#     template = models.CharField(max_length=255)
+#     recipients = models.CharField(max_length=255)
+#     content = models.TextField()

app/helper/email_service/sender.py

-# import os
-# from django.core.mail import send_mail
+import os
+from django.core.mail import send_mail
+
+from app.entities import models
+from django.conf import settings
+
+
+# def account_created(args, username, password, receiver) :
+def account_created(args):
+
+  F = open(os.path.join(settings.EMAIL_TEMPLATES_ROOT, 'RMS-NEWUSER.html'), 'r')
+
+  FC = F.read()
+
+  FC = FC.replace('{name}', args[0])
+  FC = FC.replace('{username}', args[1])
+  FC = FC.replace('{password}', args[2])
+  FC = FC.replace('[URL]', settings.FRONT_END_URL)
+
+  send_mail(
+      subject='OB IMS: Welcome!',
+      message='',
+      from_email=settings.EMAIL_DEFAULT_SENDER,
+      recipient_list=[args[3],],
+      html_message=FC,
+      fail_silently=True
+  )
+
+
+#   try:
+#       send_mail(
+#           subject='OB IMS: Welcome!',
+#           message='',
+#           from_email=settings.EMAIL_DEFAULT_SENDER,
+#           recipient_list=[args[3],],
+#           html_message=FC,
+#           fail_silently=True
+#       )
+#   except Exception as e:
+#       models.EmailLogs.insert(
+
+#       )
+
+
+# def account_created(name, username, password, receiver):
+
+#   F = open(os.path.join(
+#       settings.EMAIL_TEMPLATES_ROOT, 'RMS-NEWUSER.html'), 'r'
+#   )
+
+#   FC = F.read()
+
+#   FC = FC.replace('{name}', name)
+#   FC = FC.replace('{username}', username)
+#   FC = FC.replace('{password}', password)
+#   FC = FC.replace('[URL]', settings.FRONT_END_URL)
+
+#   send_mail(
+#     subject='RMS: Welcome!',
+#     message='',
+#     from_email=settings.EMAIL_DEFAULT_SENDER,
+#     recipient_list=[receiver,],
+#     html_message=FC
+#   )
+
 
-# from src.entities import models
-# from django.conf import settings
 
 
 # def forgot_password(reset_code, url, receiver) :

app/helper/email_service/templates/RMS-NEWUSER.html

+<!DOCTYPE html>
+<html>
+<head>
+<title>RMS: New User Created</title>
+</head>
+<body style="font-family: arial;">
+
+<div style="max-width:100px!important;">
+<img src="https://s18.directupload.net/images/190807/wjwrxx5i.jpg"/>
+</div>
+
+<h3>Resource Management System &#40;RMS&#41;</h3>
+<h3 style="color:#888888;">New User Created</h3><br>
+
+<p>Dear {name},</p><br>
+<p>You have been created as a new user of RMS. Please see your default login details below.</p><br>
+    
+<b>Username</b><br>{username}<br><br>
+<b>Password</b><br>{password}<br><br>
+
+<p>You may change your password through the <u><a href="http://staging.rms.oneberrysystem.com/cms/profile/" style="text-decoration:underline;color:#007bff;" target="_blank">my profile</a></u> section of RMS any time.</p><br>
+    
+<p>Sincerely,</p>
+<p>RMS Team</p><br><br>
+    
+<p>Powered by</p>
+<img src="https://s18.directupload.net/images/190807/jaewp4nx.png" width="120px"/>
+    
+</body>
+</html>
\ No newline at end of file

config/settings/base.py

@@ -170,9 +170,9 @@ REST_FRAMEWORK = {
 EMAIL_TEMPLATES_ROOT = os.path.join(BASE_DIR, "app/helper/email_service/templates")
 EMAIL_HOST = 'email-smtp.us-west-2.amazonaws.com'
 EMAIL_PORT = 587
-EMAIL_HOST_USER = 'AKIAIPRWQKYV6N5SMLUA'
+EMAIL_HOST_USER = 'AKIAIPRWQKYV6N5SMLUAs'
 EMAIL_HOST_PASSWORD = 'ApK1dtH2qpT/oMl9MEauFvyN9XZDQ1fjzd8TumIs71NG'
 EMAIL_USE_SSL = False
 EMAIL_USE_TLS = True
 EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
-EMAIL_DEFAULT_SENDER = 'ims.noreply@oneberrysystem.com'
+EMAIL_DEFAULT_SENDER = 'rms.noreply@oneberrysystem.com'